Replace container cleanup logic with cleanup policy check after function deploys.

Author: taeold

Diff for: src/commands/functions-artifacts-setpolicy.ts

@@ -26,8 +26,8 @@ export const command = new Command("functions:artifacts:setpolicy")
   )
   .option(
     "--days <days>",
-    "Number of days to keep container images before deletion. Default is 3 days.",
-    "3",
+    `Number of days to keep container images before deletion. Default is ${artifacts.DEFAULT_CLEANUP_DAYS} day.`,
+    `${artifacts.DEFAULT_CLEANUP_DAYS}`,
   )
   .option(
     "--none",
@@ -51,7 +51,7 @@ export const command = new Command("functions:artifacts:setpolicy")
   .action(async (options: any) => {
     const projectId = needProjectId(options);
     const location = options.location || "us-central1";
-    let daysToKeep = parseInt(options.days || "3", 10);
+    let daysToKeep = parseInt(options.days, 10);
 
     const repoPath = artifacts.makeRepoPath(projectId, location);
     let repository: artifactregistry.Repository;

Diff for: src/deploy/functions/release/index.ts

@@ -3,20 +3,21 @@ import * as clc from "colorette";
 import { Options } from "../../../options";
 import { logger } from "../../../logger";
 import { reduceFlat } from "../../../functional";
+import * as utils from "../../../utils";
 import * as args from "../args";
 import * as backend from "../backend";
-import * as containerCleaner from "../containerCleaner";
 import * as planner from "./planner";
 import * as fabricator from "./fabricator";
 import * as reporter from "./reporter";
 import * as executor from "./executor";
 import * as prompts from "../prompts";
-import * as experiments from "../../../experiments";
 import { getAppEngineLocation } from "../../../functionsConfig";
 import { getFunctionLabel } from "../functionsDeployHelper";
 import { FirebaseError } from "../../../error";
 import { getProjectNumber } from "../../../getProjectNumber";
 import { release as extRelease } from "../../extensions";
+import * as artifactregistry from "../../../gcp/artifactregistry";
+import * as artifacts from "../../../functions/artifacts";
 
 /** Releases new versions of functions and extensions to prod. */
 export async function release(
@@ -105,12 +106,8 @@ export async function release(
   printTriggerUrls(wantBackend);
 
   const haveEndpoints = backend.allEndpoints(wantBackend);
-  const deletedEndpoints = Object.values(plan)
-    .map((r) => r.endpointsToDelete)
-    .reduce(reduceFlat, []);
-  if (experiments.isEnabled("automaticallydeletegcfartifacts")) {
-    await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints);
-  }
+
+  await checkArtifactCleanupPolicies(options.projectId!, haveEndpoints);
 
   const allErrors = summary.results.filter((r) => r.error).map((r) => r.error) as Error[];
   if (allErrors.length) {
@@ -144,3 +141,119 @@ export function printTriggerUrls(results: backend.Backend): void {
     logger.info(clc.bold("Function URL"), `(${getFunctionLabel(httpsFunc)}):`, httpsFunc.uri);
   }
 }
+
+/**
+ * Checks if artifact cleanup policies are set for the regions where functions are deployed
+ * and automatically sets up policies where needed.
+ *
+ * The policy is only set up when:
+ * 1. No cleanup policy exists yet
+ * 2. No other cleanup policies exist (beyond our own if we previously set one)
+ * 3. User has not explicitly opted out
+ */
+async function checkArtifactCleanupPolicies(
+  projectId: string,
+  endpoints: backend.Endpoint[],
+): Promise<void> {
+  if (endpoints.length === 0) {
+    return;
+  }
+
+  const uniqueRegions = new Set<string>();
+  for (const endpoint of endpoints) {
+    uniqueRegions.add(endpoint.region);
+  }
+
+  const regionResults = await Promise.all(
+    Array.from(uniqueRegions).map(async (region) => {
+      try {
+        const repoPath = artifacts.makeRepoPath(projectId, region);
+        const repository = await artifactregistry.getRepository(repoPath);
+        const existingPolicy = artifacts.findExistingPolicy(repository);
+        const hasPolicy = !!existingPolicy;
+        const hasOptOut = artifacts.hasCleanupOptOut(repository);
+
+        // Check if there are any other cleanup policies beyond our own
+        const hasOtherPolicies =
+          repository.cleanupPolicies &&
+          Object.keys(repository.cleanupPolicies).some(
+            (key) => key !== artifacts.CLEANUP_POLICY_ID,
+          );
+
+        return {
+          region,
+          repository,
+          hasPolicy,
+          hasOptOut,
+          hasOtherPolicies,
+        };
+      } catch (err) {
+        logger.debug(`Failed to check artifact cleanup policy for region ${region}:`, err);
+        return {
+          region,
+          hasPolicy: false,
+          hasOptOut: false,
+          hasOtherPolicies: false,
+          error: err,
+        };
+      }
+    }),
+  );
+
+  const regionsWithErrors = regionResults
+    .filter((result) => result.error)
+    .map((result) => result.region);
+
+  const regionsToSetup = regionResults.filter(
+    (result) => !result.hasPolicy && !result.hasOptOut && !result.hasOtherPolicies && !result.error,
+  );
+
+  const regionsNeedingWarning: string[] = [];
+
+  if (regionsToSetup.length > 0) {
+    utils.logLabeledSuccess(
+      "functions",
+      `Configuring a cleanup policy for repositories in ${regionsToSetup.join(", ")}. ` +
+        `Images older than ${artifacts.DEFAULT_CLEANUP_DAYS} days will be automatically deleted.`,
+    );
+    const setupResults = await Promise.all(
+      regionsToSetup.map(async (result) => {
+        try {
+          logger.debug(`Setting up artifact cleanup policy for region ${result.region}`);
+          await artifacts.setCleanupPolicy(result.repository, artifacts.DEFAULT_CLEANUP_DAYS);
+          return { region: result.region, success: true };
+        } catch (err) {
+          logger.debug(
+            `Failed to set up artifact cleanup policy for region ${result.region}:`,
+            err,
+          );
+          regionsNeedingWarning.push(result.region);
+          return { region: result.region, success: false, error: err };
+        }
+      }),
+    );
+
+    const failedSetups = setupResults.filter((r) => !r.success);
+    if (failedSetups.length > 0) {
+      logger.debug(
+        `Failed to set up artifact cleanup policies for ${failedSetups.length} regions:`,
+        failedSetups.map((f) => f.region).join(", "),
+      );
+    }
+  }
+
+  const regionsToWarn = [...regionsNeedingWarning, ...regionsWithErrors];
+
+  if (regionsToWarn.length > 0) {
+    utils.logLabeledWarning(
+      "functions",
+      `No cleanup policy detected for repositories in ${regionsToWarn.length > 1 ? "regions" : "region"} ` +
+        `${regionsToWarn.join(", ")}. ` +
+        "This could result in a small monthly bill as container images accumulate over time.",
+    );
+    utils.logLabeledBullet(
+      "functions",
+      "Run 'firebase functions:artifacts:setpolicy' to set up a cleanup policy to automatically delete old images.",
+    );
+  }
+}

Diff for: src/experiments.ts

@@ -58,21 +58,6 @@ export const ALL_EXPERIMENTS = experiments({
     public: true,
   },
 
-  // permanent experiment
-  automaticallydeletegcfartifacts: {
-    shortDescription: "Control whether functions cleans up images after deploys",
-    fullDescription:
-      "To control costs, Firebase defaults to automatically deleting containers " +
-      "created during the build process. This has the side-effect of preventing " +
-      "users from rolling back to previous revisions using the Run API. To change " +
-      `this behavior, call ${bold("experiments:disable deletegcfartifactsondeploy")} ` +
-      `consider also calling ${bold("experiments:enable deletegcfartifacts")} ` +
-      `to enable the new command ${bold("functions:deletegcfartifacts")} which` +
-      "lets you clean up images manually",
-    public: true,
-    default: true,
-  },
-
   // Emulator experiments
   emulatoruisnapshot: {
     shortDescription: "Load pre-release versions of the emulator UI",

Diff for: src/functions/artifacts.ts

@@ -17,6 +17,11 @@ export const CLEANUP_POLICY_ID = "firebase-functions-cleanup";
  */
 export const OPT_OUT_LABEL_KEY = "firebase-functions-cleanup-opted-out";
 
+/**
+ * Default number of days to keep container images for cleanup policies
+ */
+export const DEFAULT_CLEANUP_DAYS = 1;
+
 const SECONDS_IN_DAY = 24 * 60 * 60;
 
 /**