@catladder/pipeline 0.0.0-refactore-catenv-command-validates-argument-78d05852 → 0.0.0-reference-database-url-1befbbee

package/src/deploy/cloudRun/createJobs/cloudRunServices.ts

@@ -1,8 +1,9 @@
 import { getLabels } from "../../../context/getLabels";
-import type { Context } from "../../../types/context";
+import type { ComponentContext } from "../../../types/context";
 
 import type { DeployConfigCloudRunService } from "../../types/googleCloudRun";
 import { createArgsString } from "../utils/createArgsString";
+import { getCloudRunServiceOrJobArgsArg } from "../utils/getJobOrServiceArgs";
 import { getServiceName } from "../utils/getServiceName";
 import {
   gcloudRunCmd,
@@ -10,11 +11,14 @@ import {
   getCommonDeployArgs,
   makeLabelString,
 } from "./common";
+import { ENV_VARS_FILENAME } from "./constants";
+import { healthCheckCliArgs } from "./healthCheck";
+import { createVolumeConfig } from "./volumes";
 
 export const getServiceDeployScript = (
-  context: Context,
+  context: ComponentContext,
   service: DeployConfigCloudRunService | true | undefined,
-  nameSuffix?: string
+  nameSuffix?: string,
 ) => {
   const commonDeployArgs = getCommonDeployArgs(context);
 
@@ -23,7 +27,10 @@ export const getServiceDeployScript = (
   const customConfig = service !== true ? service : undefined;
   const command =
     service !== true
-      ? service?.command ?? context.componentConfig.build.startCommand
+      ? (service?.command ??
+        (context.build.type !== "disabled"
+          ? context.build.config.startCommand
+          : undefined))
       : undefined;
 
   const commandArray = command
@@ -31,32 +38,48 @@ export const getServiceDeployScript = (
       ? command
       : command.split(" ")
     : undefined;
-  const fullServiceName = `${serviceName}${nameSuffix ?? ""}`;
-  const argsString = createArgsString({
-    // command as empty string resets it to default (uses the image's entrypoint)
-    command: commandArray ? '"' + commandArray.join(",") + '"' : '""',
-    ...commonDeployArgs,
-    labels: makeLabelString({
-      ...getLabels(context),
-      "cloud-run-service-name": fullServiceName,
-    }),
-    "env-vars-file": "____envvars.yaml",
-    "min-instances": customConfig?.minInstances ?? 0,
-    "max-instances": customConfig?.maxInstances ?? 100,
-    "cpu-throttling": customConfig?.noCpuThrottling !== true,
-    memory: customConfig?.memory,
-    "allow-unauthenticated": customConfig?.allowUnauthenticated ?? true,
-    ingress: customConfig?.ingress ?? "all",
-    "cpu-boost": true,
-    "execution-environment": customConfig?.executionEnvironment,
-  });
+  const fullServiceName = serviceName.concat(nameSuffix ?? "");
 
-  return `${gcloudRunCmd()} deploy ${fullServiceName} ${argsString}`;
+  const argsString = createArgsString(
+    {
+      // command as empty string resets it to default (uses the image's entrypoint)
+      command: commandArray ? '"' + commandArray.join(",") + '"' : '""',
+      args: getCloudRunServiceOrJobArgsArg(customConfig?.args),
+      ...commonDeployArgs,
+      image: customConfig?.image ?? commonDeployArgs.image,
+      labels: makeLabelString({
+        ...getLabels(context),
+        "cloud-run-service-name": fullServiceName,
+      }),
+      "env-vars-file": ENV_VARS_FILENAME,
+      "min-instances": customConfig?.minInstances ?? 0,
+      "max-instances": customConfig?.maxInstances ?? 100,
+      "cpu-throttling": customConfig?.noCpuThrottling !== true,
+      cpu: customConfig?.cpu,
+      memory: customConfig?.memory,
+      timeout: customConfig?.timeout,
+      "vpc-connector": customConfig?.vpcConnector,
+      "vpc-egress": customConfig?.vpcEgress,
+      network: customConfig?.network,
+      subnet: customConfig?.subnet,
+      "use-http2": customConfig?.http2,
+      "allow-unauthenticated": customConfig?.allowUnauthenticated ?? true,
+      ingress: customConfig?.ingress ?? "all",
+      "cpu-boost": true,
+      "execution-environment": customConfig?.executionEnvironment,
+      gpu: customConfig?.gpu,
+      "gpu-type": customConfig?.gpuType,
+      ...healthCheckCliArgs(customConfig?.healthCheck),
+    },
+    ...createVolumeConfig(customConfig?.volumes, "service"),
+  );
+  const version = requiresBeta(customConfig) ? "beta" : undefined;
+  return `${gcloudRunCmd(version)} deploy ${fullServiceName} ${argsString}`;
 };
 
 export const getServiceDeleteScript = (
-  context: Context,
-  serviceSuffix?: string
+  context: ComponentContext,
+  serviceSuffix?: string,
 ) => {
   const commonArgs = getCommonCloudRunArgs(context);
 
@@ -72,3 +95,19 @@ export const getServiceDeleteScript = (
     `${gcloudRunCmd()} services delete ${fullServiceName} ${commonArgsString}`,
   ];
 };
+const requiresBeta = (config: DeployConfigCloudRunService | undefined) => {
+  if (!config) {
+    return false;
+  }
+
+  if (config.gpuType) {
+    return true;
+  }
+  if (config.gpu && config.gpu > 0) {
+    return true;
+  }
+  if (config.healthCheck !== undefined) {
+    return true;
+  }
+  return false;
+};

package/src/deploy/cloudRun/createJobs/common.ts

@@ -1,4 +1,4 @@
-import type { Context } from "../../../types/context";
+import type { ComponentContext } from "../../../types/context";
 
 import { isOfDeployType } from "../../types";
 import type { DeployConfigCloudRun } from "../../types/googleCloudRun";
@@ -16,12 +16,12 @@ export const gcloudSchedulerCmd = (version?: "beta") => {
 };
 
 export const setGoogleProjectNumberScript = (
-  deployConfig: DeployConfigCloudRun
+  deployConfig: DeployConfigCloudRun,
 ) => [
   `export GCLOUD_PROJECT_NUMBER=$(${gcloudCmd()} projects describe ${
     deployConfig.projectId
   } --format="value(projectNumber)")`,
-  `echo "GCLOUD_PROJECT_NUMBER: $GCLOUD_PROJECT_NUMBER"`,
+  'echo "GCLOUD_PROJECT_NUMBER: $GCLOUD_PROJECT_NUMBER"',
 ];
 
 export const makeLabelString = (obj: Record<string, unknown>) =>
@@ -29,8 +29,8 @@ export const makeLabelString = (obj: Record<string, unknown>) =>
     .map(([key, value]) => `${key}=${value}`)
     .join(",");
 
-export const getCloudRunDeployConfig = (context: Context) => {
-  const deployConfig = context.componentConfig.deploy;
+export const getCloudRunDeployConfig = (context: ComponentContext) => {
+  const deployConfig = context.deploy?.config;
   if (!isOfDeployType(deployConfig, "google-cloudrun")) {
     // should not happen
     throw new Error("deploy config is wrong");
@@ -38,7 +38,7 @@ export const getCloudRunDeployConfig = (context: Context) => {
   return deployConfig;
 };
 
-export function getCommonCloudRunArgs(context: Context) {
+export function getCommonCloudRunArgs(context: ComponentContext) {
   const deployConfig = getCloudRunDeployConfig(context);
   return {
     project: deployConfig.projectId,
@@ -46,7 +46,7 @@ export function getCommonCloudRunArgs(context: Context) {
   };
 }
 
-export function getCommonDeployArgs(context: Context) {
+export function getCommonDeployArgs(context: ComponentContext) {
   const commonArgs = getCommonCloudRunArgs(context);
   const deployConfig = getCloudRunDeployConfig(context);
   return {

package/src/deploy/cloudRun/createJobs/constants.ts

@@ -0,0 +1 @@
+export const ENV_VARS_FILENAME = "____envvars.yaml";

package/src/deploy/cloudRun/createJobs/execute/onDeploy.ts

@@ -0,0 +1,102 @@
+import type { StringOrBashExpression } from "../../../../bash";
+import type { ComponentContext } from "../../../../types/context";
+import type {
+  DeployConfigCloudRunExecuteOnDeploy,
+  DeployConfigCloudRunJob,
+  DeployConfigCloudRunService,
+} from "../../../types/googleCloudRun";
+import { createArgsString } from "../../utils/createArgsString";
+import { getCloudRunServiceOrJobArgsArg } from "../../utils/getJobOrServiceArgs";
+import { getFullJobName } from "../../utils/jobName";
+import { getCloudRunJobsWithNames } from "../cloudRunJobs";
+import {
+  gcloudRunCmd,
+  getCloudRunDeployConfig,
+  getCommonCloudRunArgs,
+} from "../common";
+
+type Execute = {
+  jobName: StringOrBashExpression;
+  config: DeployConfigCloudRunExecuteOnDeploy;
+};
+export const getOnDeployExecuteScript = (
+  context: ComponentContext,
+  when: DeployConfigCloudRunExecuteOnDeploy["when"],
+) => {
+  const executes = getExecutes(context);
+
+  return executes
+    .filter(({ config }) => config.when === when)
+    .map((execute) => {
+      return getJobRunScriptForExecute(context, execute);
+    });
+};
+
+const getExecutes = (context: ComponentContext): Execute[] => {
+  const deployConfig = getCloudRunDeployConfig(context);
+  return [
+    ...getLegacyExecutes(context),
+    ...Object.entries(deployConfig.execute ?? {}).flatMap(([key, value]) => {
+      if (!value || (value.when !== "schedule" && value.type !== "job")) {
+        return [];
+      }
+      return [
+        {
+          jobName: key,
+          config: value,
+        } as Execute,
+      ];
+    }),
+  ];
+};
+
+const getLegacyExecutes = (context: ComponentContext): Execute[] => {
+  const jobsWithNames = getCloudRunJobsWithNames(context);
+
+  return jobsWithNames.flatMap(({ jobName, job }) => {
+    if (
+      !job.when ||
+      !["preDeploy", "postDeploy", "preStop", "postStop"].includes(job.when)
+    ) {
+      return [];
+    }
+    return [
+      {
+        jobName,
+        config: {
+          job: jobName,
+          type: "job",
+          when: job.when,
+          ...(job.when === "preDeploy" || job.when === "postDeploy"
+            ? {
+                waitForCompletion: job.waitForCompletion,
+              }
+            : {}),
+        } as Execute["config"],
+      },
+    ];
+  });
+};
+
+const getJobRunScriptForExecute = (
+  context: ComponentContext,
+  { jobName, config }: Execute,
+) => {
+  const commonArgs = getCommonCloudRunArgs(context);
+
+  // always wait for completion for preStop and postStop jobs
+  // since stop will delete the jobs afterwards, so they will fail
+  const waitForCompletion = ["preStop", "postStop"].includes(config.when)
+    ? true // always
+    : "waitForCompletion" in config
+      ? (config.waitForCompletion ?? false) // depends on config
+      : false;
+
+  const argString = createArgsString({
+    ...commonArgs,
+    wait: waitForCompletion === true ? true : undefined,
+    args: getCloudRunServiceOrJobArgsArg(config.args),
+  });
+  const fullJobName = getFullJobName(context, jobName);
+  return `${gcloudRunCmd()} jobs execute ${fullJobName.toString()} ${argString}`;
+};

package/src/deploy/cloudRun/createJobs/execute/schedules.ts

@@ -0,0 +1,186 @@
+import { bashEscape } from "../../../../bash";
+import type {
+  BashExpression,
+  StringOrBashExpression,
+} from "../../../../bash/BashExpression";
+import type { ComponentContext } from "../../../../types/context";
+import { notNil } from "../../../../utils";
+import type {
+  DeployConfigCloudRunExecuteWithSchedule,
+  DeployConfigCloudRunJobWithSchedule,
+} from "../../../types";
+import { getCloudRunJobExecuteUrl } from "../../utils/cloudRunExecutionUrl";
+import { createArgsString } from "../../utils/createArgsString";
+import { getFullSchedulerName } from "../../utils/jobName";
+import { getCloudRunJobsWithNames } from "../cloudRunJobs";
+import { gcloudSchedulerCmd, getCloudRunDeployConfig } from "../common";
+
+export const getDeleteSchedulesScript = (context: ComponentContext) => {
+  const deployConfig = getCloudRunDeployConfig(context);
+  const schedules = getSchedules(context);
+  const argsString = createArgsString({
+    project: deployConfig.projectId,
+    location: deployConfig.region,
+  });
+
+  return schedules
+    .map(({ fullName }) => {
+      return [`${gcloudSchedulerCmd()} jobs delete ${fullName} ${argsString}`];
+    })
+    .flat();
+};
+
+export const getCreateScheduleScript = (
+  context: ComponentContext,
+): string[] => {
+  const schedules = getSchedules(context);
+  const { region: location, projectId: project } =
+    getCloudRunDeployConfig(context);
+
+  return schedules.map(({ fullName, config }, jobIndex): string => {
+    const { uri, ...args } = getSchedulerArgs(config, context);
+
+    const argsString = createArgsString({
+      project,
+      location,
+      uri: `"$current_job_uri"`,
+      ...args,
+
+      schedule: `"${config.schedule}"`,
+      "max-retry-attempts": config.maxRetryAttempts ?? 0,
+    });
+    return [
+      jobIndex === 0
+        ? `exist_scheduler_names="$(\n  ${gcloudSchedulerCmd()} jobs list --filter='httpTarget.uri ~ ${context.env}.*${context.name}' --format='value(name)' --limit=999 --location='${location}' --project='${project}'\n)"`
+        : null,
+      `current_job_uri="${uri}"`,
+      `current_scheduler_name="${fullName}"`,
+      `if grep "$current_scheduler_name" <<<"$exist_scheduler_names" >/dev/null; then`,
+      `  ${gcloudSchedulerCmd()} jobs update http "$current_scheduler_name" ${argsString}`,
+      `else`,
+      `  ${gcloudSchedulerCmd()} jobs create http "$current_scheduler_name" ${argsString}`,
+      `fi`,
+    ]
+      .filter(notNil)
+      .join("\n");
+  });
+};
+
+const getSchedulerArgs = (
+  scheduler: DeployConfigCloudRunExecuteWithSchedule,
+  context: ComponentContext,
+): {
+  uri: string;
+  "http-method"?: string;
+  "message-body"?: string;
+  "oauth-service-account-email"?: string;
+  "oidc-service-account-email"?: string;
+} => {
+  if (scheduler.type === "job") {
+    const { projectId, region } = getCloudRunDeployConfig(context);
+    const body =
+      scheduler.args !== undefined
+        ? {
+            overrides: {
+              containerOverrides: [
+                scheduler.args?.length > 0
+                  ? {
+                      args: scheduler.args,
+                    }
+                  : {
+                      args: [],
+                      clearArgs: true, // not sure why this is neeeded, but it is
+                    },
+              ],
+            },
+          }
+        : null;
+    return {
+      uri: getCloudRunJobExecuteUrl(scheduler.job, {
+        appFullName: context.environment.fullName,
+        projectId,
+        region,
+      }),
+      "message-body": body
+        ? '"' + bashEscape(JSON.stringify(body)) + '"'
+        : undefined,
+      "http-method": "POST",
+      "oauth-service-account-email": `"$GCLOUD_PROJECT_NUMBER-compute@developer.gserviceaccount.com"`,
+    };
+  }
+  if (scheduler.type === "http") {
+    return {
+      uri: scheduler.url,
+      "message-body": scheduler.body,
+      "http-method": scheduler.method,
+      "oidc-service-account-email": `"$GCLOUD_PROJECT_NUMBER-compute@developer.gserviceaccount.com"`,
+    };
+  }
+  throw new Error(`Unknown scheduler type: ${(scheduler as any).type}`);
+};
+
+const getSchedules = (
+  context: ComponentContext,
+): {
+  name: string;
+  fullName: StringOrBashExpression;
+  config: DeployConfigCloudRunExecuteWithSchedule;
+}[] => {
+  const legacyScheduleJobs = getLegacyJobSchedules(context);
+  const schedules = getScheduledExecutes(context);
+
+  return Object.entries({ ...legacyScheduleJobs, ...schedules }).map(
+    ([name, config]) => ({
+      name,
+      fullName: getFullSchedulerName(context, name),
+      config,
+    }),
+  );
+};
+
+const getLegacyJobSchedules = (
+  context: ComponentContext,
+): Record<string, DeployConfigCloudRunExecuteWithSchedule> => {
+  const jobsWithNames = getCloudRunJobsWithNames(context);
+
+  return Object.fromEntries(
+    jobsWithNames
+      .filter(
+        (
+          entry,
+        ): entry is {
+          fullJobName: BashExpression;
+          job: DeployConfigCloudRunJobWithSchedule;
+          jobName: string;
+        } => entry.job.when === "schedule",
+      )
+      .map(({ job: { maxRetryAttempts, schedule }, jobName }) => {
+        const schedulerName = jobName.concat("-scheduler");
+        return [
+          schedulerName,
+          {
+            type: "job",
+            job: jobName,
+            maxRetryAttempts,
+            schedule,
+            when: "schedule",
+          },
+        ];
+      }),
+  );
+};
+
+const getScheduledExecutes = (
+  context: ComponentContext,
+): Record<string, DeployConfigCloudRunExecuteWithSchedule> => {
+  const deployConfig = getCloudRunDeployConfig(context);
+
+  return Object.fromEntries(
+    Object.entries(deployConfig.execute ?? {}).flatMap(([key, value]) => {
+      if (!value || value.when !== "schedule") {
+        return [];
+      }
+      return [[key, value]];
+    }),
+  );
+};

package/src/deploy/cloudRun/createJobs/getCloudRunDeployScripts.ts

@@ -1,57 +1,68 @@
-import type { Context } from "../../../types/context";
+import { omit } from "lodash";
+import type { ComponentContext } from "../../../types/context";
 import { collapseableSection } from "../../../utils/gitlab";
 import { getDependencyTrackUploadScript } from "../../sbom";
 
+import { GCLOUD_DEPLOY_CREDENTIALS_KEY } from "..";
+import { writeBashYamlToFileScript } from "../../../bash/bashYaml";
 import { getRemoveOldRevisionsAndImagesCommand } from "../cleanup";
 import { getDatabaseCreateScript } from "../utils/database";
 import { gcloudServiceAccountLoginCommands } from "../utils/gcloudServiceAccountLoginCommands";
-import {
-  getCreateScheduleScripts,
-  getJobCreateScripts,
-  getJobRunScripts,
-} from "./cloudRunJobs";
+import { getJobCreateScripts } from "./cloudRunJobs";
+import { getOnDeployExecuteScript } from "./execute/onDeploy";
 import { getServiceDeployScript } from "./cloudRunServices";
 import {
   getCloudRunDeployConfig,
   setGoogleProjectNumberScript,
 } from "./common";
+import { ENV_VARS_FILENAME } from "./constants";
+import { getCreateScheduleScript } from "./execute/schedules";
 
-export function getCloudRunDeployScripts(context: Context) {
+export function getCloudRunDeployScripts(context: ComponentContext) {
   const deployConfig = getCloudRunDeployConfig(context);
+  const allEnvVars = omit(
+    context.environment.envVars,
+    GCLOUD_DEPLOY_CREDENTIALS_KEY,
+  );
+
   return [
     ...collapseableSection(
       "prepare",
-      "Prepare..."
+      "Prepare...",
     )([
       ...gcloudServiceAccountLoginCommands(context),
       ...setGoogleProjectNumberScript(deployConfig),
     ]),
+    ...collapseableSection(
+      "writeenvvars",
+      "Write env vars to file",
+    )(writeBashYamlToFileScript(allEnvVars, ENV_VARS_FILENAME)),
+
     ...collapseableSection(
       "deploy",
-      "Deploy to cloud run"
+      "Deploy to cloud run",
     )([
-      `echo "$ENV_VARS" > ____envvars.yaml`, // TODO: split secrets out
       ...(deployConfig.cloudSql
         ? getDatabaseCreateScript(context, deployConfig) // we create the db, so that we can also delete it afterwards
         : []),
-      ...getCreateScheduleScripts(context),
+      ...getCreateScheduleScript(context),
       ...getJobCreateScripts(context),
-      ...getJobRunScripts(context, "preDeploy"),
+      ...getOnDeployExecuteScript(context, "preDeploy"),
 
       ...(deployConfig.service !== false
         ? [getServiceDeployScript(context, deployConfig.service)]
         : []),
       ...Object.entries(deployConfig.additionalServices ?? {}).map(
         ([name, service]) =>
-          getServiceDeployScript(context, service, "-" + name)
+          getServiceDeployScript(context, service, "-" + name),
       ),
-      ...getJobRunScripts(context, "postDeploy"),
+      ...getOnDeployExecuteScript(context, "postDeploy"),
     ]),
     ...collapseableSection(
       "cleanup",
-      "Cleanup"
+      "Cleanup",
     )(
-      getRemoveOldRevisionsAndImagesCommand(context, "postDeploy") // we cleanup inactive images both on deploy and stop
+      getRemoveOldRevisionsAndImagesCommand(context, "postDeploy"), // we cleanup inactive images both on deploy and stop
     ),
     ...getDependencyTrackUploadScript(context),
   ];

package/src/deploy/cloudRun/createJobs/getCloudRunStopScripts.ts

@@ -1,28 +1,26 @@
-import type { Context } from "../../../types/context";
+import type { ComponentContext } from "../../../types/context";
 import { getDependencyTrackDeleteScript } from "../../sbom";
 
 import { getRemoveOldRevisionsAndImagesCommand } from "../cleanup";
 import { getDatabaseDeleteScript } from "../utils/database";
 import { gcloudServiceAccountLoginCommands } from "../utils/gcloudServiceAccountLoginCommands";
-import {
-  getDeleteJobsScripts,
-  getDeleteSchedulesScripts,
-  getJobRunScripts,
-} from "./cloudRunJobs";
+import { getDeleteJobsScripts } from "./cloudRunJobs";
+import { getOnDeployExecuteScript } from "./execute/onDeploy";
+import { getDeleteSchedulesScript } from "./execute/schedules";
 import { getServiceDeleteScript } from "./cloudRunServices";
 import { getCloudRunDeployConfig } from "./common";
 
-export function getCloudRunStopScripts(context: Context) {
+export function getCloudRunStopScripts(context: ComponentContext) {
   const deployConfig = getCloudRunDeployConfig(context);
   return [
     ...gcloudServiceAccountLoginCommands(context),
-    ...getJobRunScripts(context, "preStop"),
+    ...getOnDeployExecuteScript(context, "preStop"),
     ...(deployConfig.service !== false ? getServiceDeleteScript(context) : []),
     ...Object.entries(deployConfig.additionalServices ?? {}).flatMap(([name]) =>
-      getServiceDeleteScript(context, name)
+      getServiceDeleteScript(context, name),
     ),
-    ...getJobRunScripts(context, "postStop"),
-    ...getDeleteSchedulesScripts(context),
+    ...getOnDeployExecuteScript(context, "postStop"),
+    ...getDeleteSchedulesScript(context),
     ...getDeleteJobsScripts(context),
     ...(deployConfig.cloudSql && deployConfig.cloudSql.deleteDatabaseOnStop
       ? getDatabaseDeleteScript(context, deployConfig)

package/src/deploy/cloudRun/createJobs/healthCheck.ts

@@ -0,0 +1,64 @@
+import type { DeployConfigCloudRunProbeShared } from "../../types";
+import {
+  defaultLivenessProbe,
+  defaultStartupProbe,
+  type DeployConfigCloudRunProbe,
+  type DeployConfigCloudRunService,
+} from "../../types";
+
+const PORT = 8080;
+
+export function healthCheckCliArgs(
+  healthCheck: DeployConfigCloudRunService["healthCheck"],
+) {
+  const shouldNotSetHealthCheck = healthCheck === undefined;
+  if (shouldNotSetHealthCheck) {
+    return undefined;
+  }
+
+  const shouldUseDefaultProbe = healthCheck === true;
+
+  if (shouldUseDefaultProbe) {
+    return {
+      "startup-probe": toArgValue(probeToKeyValuePairs(defaultStartupProbe)),
+      "liveness-probe": toArgValue(probeToKeyValuePairs(defaultLivenessProbe)),
+    };
+  }
+
+  return {
+    "startup-probe": toArgValue(probeToKeyValuePairs(healthCheck.startupProbe)),
+    "liveness-probe": healthCheck.livenessProbe
+      ? toArgValue(probeToKeyValuePairs(healthCheck.livenessProbe))
+      : "", // NOTE: empty string ("") removes liveness probe
+  };
+}
+
+function probeToKeyValuePairs(
+  probe: DeployConfigCloudRunProbe,
+): [string, unknown][] {
+  const sharedArgs = Object.entries({
+    initialDelaySeconds: probe.initialDelaySeconds,
+    timeoutSeconds: probe.timeoutSeconds,
+    periodSeconds: probe.periodSeconds,
+    failureThreshold: probe.failureThreshold,
+  } satisfies DeployConfigCloudRunProbeShared);
+
+  switch (probe.type) {
+    case "tcp":
+      return [...sharedArgs, ["tcpSocket.port", PORT]];
+    case "http1":
+      return [
+        ...sharedArgs,
+        ["httpGet.port", PORT],
+        ["httpGet.path", probe.path],
+        // NOTE: headers are not supported by "gcloud beta" at the moment
+      ];
+    default:
+      probe satisfies never;
+      return [];
+  }
+}
+
+function toArgValue(keyValues: [string, unknown][]) {
+  return keyValues.map(([key, value]) => `${key}=${value}`).join(",");
+}