@google-cloud/cloud-run-mcp 1.9.0 → 1.11.0

package/lib/deployment/deployer.js

@@ -22,9 +22,15 @@ import {
   uploadToStorageBucket,
 } from '../cloud-api/storage.js';
 import { ensureArtifactRegistryRepoExists } from '../cloud-api/registry.js';
-import { triggerCloudBuild } from '../cloud-api/build.js';
-import { logAndProgress } from '../util/helpers.js';
-import { checkCloudRunServiceExists } from '../cloud-api/run.js';
+import { triggerCloudBuild, composeBuild } from '../cloud-api/build.js';
+import {
+  logAndProgress,
+  sanitizeCloudRunServiceName,
+} from '../util/helpers.js';
+import {
+  checkCloudRunServiceExists,
+  setServicePublicAccess,
+} from '../cloud-api/run.js';
 import {
   canDeployWithoutBuild,
   createDirectSourceDeploymentContainer,
@@ -32,16 +38,29 @@ import {
 } from './helpers.js';
 import {
   prepareSourceDirectory,
-  installDependencies,
   cleanupTempDirectory,
 } from './source-processor.js';
+import { runUniversalMaker } from './universal-maker.js';
 
 import {
   DEPLOYMENT_CONFIG,
   DEPLOYMENT_TYPES,
   MAX_ALLOWED_DIRECT_SOURCE_SIZE_BYTES,
   REQUIRED_APIS,
+  RUNTIMES,
 } from './constants.js';
+import path from 'path';
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { getRunV1Client } from '../clients.js';
+import {
+  runCompose as downloadRunCompose,
+  resourceCompose,
+  translateCompose,
+  composeVolumes,
+  composeSecrets,
+} from './compose.js';
+import { getProjectNumber } from '../util/helpers.js';
 
 /**
  * Deploys or updates a Cloud Run service with the specified container image.
@@ -68,7 +87,8 @@ async function deployToCloudRun(
   deploymentType,
   accessToken,
   zippedSourceContainer,
-  runtime
+  runtime,
+  ingress
 ) {
   const runClient = await getRunClient(projectId, accessToken);
   const parent = runClient.locationPath(projectId, location);
@@ -90,7 +110,11 @@ async function deployToCloudRun(
       'deployment-type': deploymentType,
       runtime: runtime,
     },
+    client: DEPLOYMENT_CONFIG.LABEL_CREATED_BY,
   };
+  if (ingress) {
+    service.ingress = ingress;
+  }
 
   // Conditionally set invokerIamDisabled based on the skipIamCheck flag
   if (skipIamCheck) {
@@ -248,7 +272,8 @@ async function deployWithZip(
   deploymentAttrs,
   progressCallback,
   skipIamCheck,
-  accessToken
+  accessToken,
+  ingress
 ) {
   await logAndProgress(
     `Attempting direct source deployment...`,
@@ -259,7 +284,18 @@ async function deployWithZip(
 
   try {
     tempDir = await prepareSourceDirectory(files);
-    await installDependencies(tempDir, deploymentAttrs);
+
+    if (
+      deploymentAttrs.runtime === RUNTIMES.NODEJS ||
+      deploymentAttrs.runtime === RUNTIMES.PYTHON
+    ) {
+      deploymentAttrs = await updateDeploymentAttrsWithUniversalMaker(
+        tempDir,
+        deploymentAttrs,
+        accessToken,
+        progressCallback
+      );
+    }
 
     const archiveBuffer = await zipFiles([tempDir], true, progressCallback);
     const archiveName = DEPLOYMENT_CONFIG.TARGZ_FILE_NAME;
@@ -280,10 +316,12 @@ async function deployWithZip(
       bucketName,
       region,
       accessToken,
+      undefined,
+      false,
       progressCallback
     );
 
-    await uploadToStorageBucket(
+    const file = await uploadToStorageBucket(
       bucket,
       archiveBuffer,
       archiveName,
@@ -292,7 +330,7 @@ async function deployWithZip(
     await logAndProgress('Source code uploaded successfully', progressCallback);
 
     const container = createDirectSourceDeploymentContainer({
-      bucketName,
+      bucketName: bucket.name,
       fileName: archiveName,
       deploymentAttrs,
     });
@@ -307,15 +345,57 @@ async function deployWithZip(
       DEPLOYMENT_TYPES.NO_BUILD,
       accessToken,
       container,
-      deploymentAttrs.runtime
+      deploymentAttrs.runtime,
+      ingress
     );
 
+    await logAndProgress(
+      `Deployment completed successfully with zip deploy`,
+      progressCallback
+    );
     return service;
   } finally {
     await cleanupTempDirectory(tempDir);
   }
 }
 
+/**
+ * Updates deployment attributes using result from Universal Maker.
+ *
+ * @async
+ * @param {string} tempDir - Path to the temporary source directory.
+ * @param {object} deploymentAttrs - The initial deployment attributes.
+ * @param {function(object): void} [progressCallback] - Optional callback for progress updates.
+ * @returns {Promise<object>} A promise that resolves with the updated deployment attributes.
+ */
+async function updateDeploymentAttrsWithUniversalMaker(
+  tempDir,
+  deploymentAttrs,
+  accessToken,
+  progressCallback
+) {
+  const umResult = await runUniversalMaker(
+    tempDir,
+    accessToken,
+    progressCallback
+  );
+  if (umResult) {
+    await logAndProgress(
+      'Updating deployment attributes using Universal Maker results.',
+      progressCallback
+    );
+    return {
+      ...deploymentAttrs,
+      baseImage: umResult.runtime || deploymentAttrs.baseImage,
+      runtime: umResult.runtime || deploymentAttrs.runtime,
+      cmd: umResult.command ? [umResult.command] : deploymentAttrs.cmd,
+      args: umResult.args || deploymentAttrs.args,
+      envVars: umResult.envVars || {},
+    };
+  }
+  return deploymentAttrs;
+}
+
 /**
  * Handles deployment using Google Cloud Build.
  * This function zips the source code, uploads it to Google Cloud Storage,
@@ -343,7 +423,8 @@ async function deployWithBuild(
   bucketName,
   progressCallback,
   skipIamCheck,
-  accessToken
+  accessToken,
+  ingress
 ) {
   const imageUrl = `${region}-docker.pkg.dev/${projectId}/${DEPLOYMENT_CONFIG.REPO_NAME}/${serviceName}:${DEPLOYMENT_CONFIG.IMAGE_TAG}`;
 
@@ -352,13 +433,15 @@ async function deployWithBuild(
     bucketName,
     region,
     accessToken,
+    undefined,
+    false,
     progressCallback
   );
 
   const archiveBuffer = await zipFiles(files, false, progressCallback);
   const archiveName = DEPLOYMENT_CONFIG.ZIP_FILE_NAME;
 
-  await uploadToStorageBucket(
+  const file = await uploadToStorageBucket(
     bucket,
     archiveBuffer,
     archiveName,
@@ -380,13 +463,14 @@ async function deployWithBuild(
   const buildResult = await triggerCloudBuild(
     projectId,
     region,
-    bucketName,
+    bucket.name,
     archiveName,
     DEPLOYMENT_CONFIG.REPO_NAME,
     imageUrl,
     hasDockerfile,
     accessToken,
-    progressCallback
+    progressCallback,
+    ingress
   );
 
   const builtImageUrl = buildResult.results.images[0].name;
@@ -399,10 +483,16 @@ async function deployWithBuild(
     progressCallback,
     skipIamCheck,
     DEPLOYMENT_TYPES.WITH_BUILD,
-    accessToken
+    accessToken,
+    undefined,
+    undefined,
+    ingress
   );
 
-  await logAndProgress(`Deployment completed successfully`, progressCallback);
+  await logAndProgress(
+    `Deployment completed successfully with source build deploy`,
+    progressCallback
+  );
   return service;
 }
 
@@ -425,6 +515,7 @@ export async function deploy({
   progressCallback,
   skipIamCheck,
   accessToken,
+  ingress,
 }) {
   if (!projectId) {
     const errorMsg =
@@ -433,13 +524,6 @@ export async function deploy({
     throw new Error(errorMsg);
   }
 
-  if (!serviceName) {
-    const errorMsg =
-      'Error: serviceName is required in the configuration object.';
-    await logAndProgress(errorMsg, progressCallback, 'error');
-    throw new Error(errorMsg);
-  }
-
   if (!files || !Array.isArray(files) || files.length === 0) {
     const errorMsg =
       'Error: files array is required in the configuration object.';
@@ -451,6 +535,30 @@ export async function deploy({
     }
   }
 
+  // Determines if we can use the direct source deployment (no Cloud Build) or compose deployment
+  const { hasDockerfile, composeFilePath, deploymentAttrs } =
+    makeFileDeploymentMetadata(files);
+
+  if (composeFilePath) {
+    return await deployCompose({
+      projectId,
+      serviceName,
+      region,
+      files,
+      composeFilePath,
+      progressCallback,
+      skipIamCheck,
+      accessToken,
+    });
+  }
+
+  if (!serviceName) {
+    const errorMsg =
+      'Error: serviceName is required in the configuration object.';
+    await logAndProgress(errorMsg, progressCallback, 'error');
+    throw new Error(errorMsg);
+  }
+
   try {
     await ensureApisEnabled(
       projectId,
@@ -466,10 +574,6 @@ export async function deploy({
     await logAndProgress(`Service Name: ${serviceName}`, progressCallback);
     await logAndProgress(`Files to deploy: ${files.length}`, progressCallback);
 
-    // Determines if we can use the direct source deployment (no Cloud Build)
-    const { hasDockerfile, deploymentAttrs } =
-      makeFileDeploymentMetadata(files);
-
     await logAndProgress(`Dockerfile: ${hasDockerfile}`, progressCallback);
 
     if (canDeployWithoutBuild({ hasDockerfile, deploymentAttrs })) {
@@ -483,7 +587,8 @@ export async function deploy({
           deploymentAttrs,
           progressCallback,
           skipIamCheck,
-          accessToken
+          accessToken,
+          ingress
         );
       } catch (error) {
         await logAndProgress(
@@ -503,7 +608,8 @@ export async function deploy({
       bucketName,
       progressCallback,
       skipIamCheck,
-      accessToken
+      accessToken,
+      ingress
     );
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;
@@ -533,6 +639,7 @@ export async function deployImage({
   progressCallback,
   skipIamCheck,
   accessToken,
+  ingress,
 }) {
   if (!projectId) {
     const errorMsg =
@@ -579,7 +686,10 @@ export async function deployImage({
       progressCallback,
       skipIamCheck,
       DEPLOYMENT_TYPES.IMAGE,
-      accessToken
+      accessToken,
+      undefined,
+      undefined,
+      ingress
     );
 
     await logAndProgress(`Deployment completed successfully`, progressCallback);
@@ -591,3 +701,197 @@ export async function deployImage({
     throw error;
   }
 }
+
+/**
+ * Deploys services defined in a compose.yaml file to Cloud Run.
+ *
+ * @async
+ * @param {object} config - The deployment configuration.
+ * @param {string} config.projectId - The Google Cloud project ID.
+ * @param {string} [config.serviceName] - The name of the Cloud Run service.
+ * @param {string} [config.region] - The Google Cloud region for deployment.
+ * @param {Array<string>} config.files - An array of paths to include in the source bundle.
+ * @param {string} config.composeFilePath - The absolute path to the compose configuration file.
+ * @param {function(object): void} [config.progressCallback] - Optional callback for progress updates.
+ * @param {boolean} [config.skipIamCheck=false] - Whether to skip the IAM check (if true, will attempt to set public access).
+ * @param {string} [config.accessToken] - Access token for authentication.
+ * @returns {Promise<object>} A promise that resolves with the deployment result.
+ * @throws {Error} If deployment fails or required configuration is missing.
+ */
+export async function deployCompose({
+  projectId,
+  serviceName,
+  region,
+  files,
+  composeFilePath,
+  progressCallback,
+  skipIamCheck,
+  accessToken,
+}) {
+  let tempDir;
+  try {
+    tempDir = await prepareSourceDirectory(files, progressCallback);
+    const tempComposeFilePath = path.join(
+      tempDir,
+      path.basename(composeFilePath)
+    );
+    const folderPath = tempDir;
+    const projectNumber = await getProjectNumber(projectId, accessToken);
+    const binPath = await downloadRunCompose(accessToken, progressCallback);
+
+    // Get resource configuration
+    const resourceOutput = await resourceCompose(
+      binPath,
+      tempComposeFilePath,
+      region,
+      progressCallback
+    );
+    let resourcesConfig = JSON.parse(resourceOutput);
+    if (!serviceName) {
+      serviceName = resourcesConfig.project;
+    }
+
+    // Handle source builds if any
+    if (resourcesConfig.source_builds) {
+      resourcesConfig = await composeBuild(
+        resourcesConfig,
+        accessToken,
+        projectId,
+        region,
+        folderPath,
+        progressCallback
+      );
+    }
+
+    // Handle volumes (bind and named)
+    resourcesConfig = await composeVolumes(
+      resourcesConfig,
+      accessToken,
+      projectId,
+      region,
+      folderPath,
+      progressCallback
+    );
+
+    // Handle secrets
+    resourcesConfig = await composeSecrets(
+      resourcesConfig,
+      accessToken,
+      projectId,
+      folderPath,
+      progressCallback
+    );
+
+    const result = await translateCompose(
+      binPath,
+      tempComposeFilePath,
+      region,
+      projectNumber,
+      progressCallback,
+      resourcesConfig
+    );
+
+    const translation = JSON.parse(result);
+    const deploymentItems = [];
+
+    if (translation.models) {
+      for (const [name, yamlPath] of Object.entries(translation.models)) {
+        deploymentItems.push({ name, yamlPath, type: 'model' });
+      }
+    }
+    if (translation.services) {
+      for (const [name, yamlPath] of Object.entries(translation.services)) {
+        deploymentItems.push({ name, yamlPath, type: 'service' });
+      }
+    }
+
+    const deploymentResults = {};
+    const runV1Client = await getRunV1Client(projectId, accessToken, region);
+
+    for (const { name: rawName, yamlPath, type } of deploymentItems) {
+      const serviceName = sanitizeCloudRunServiceName(rawName);
+      const fullYamlPath = path.join(folderPath, yamlPath);
+      await logAndProgress(
+        `Deploying ${type} ${serviceName} using configuration from ${fullYamlPath}...`,
+        progressCallback
+      );
+
+      const serviceConfig = yaml.load(
+        await fs.promises.readFile(fullYamlPath, 'utf8')
+      );
+
+      // Ensure the metadata name is sanitized to match
+      serviceConfig.metadata = serviceConfig.metadata || {};
+      serviceConfig.metadata.name = serviceName;
+
+      // The name for replaceService in v1 is namespaces/{project}/services/{service}
+      const name = `namespaces/${projectId}/services/${serviceName}`;
+      const parent = `namespaces/${projectId}`;
+
+      let response;
+      try {
+        response = await runV1Client.namespaces.services.replaceService({
+          name,
+          requestBody: serviceConfig,
+        });
+      } catch (error) {
+        if (error.code === 404) {
+          await logAndProgress(
+            `${type.charAt(0).toUpperCase() + type.slice(1)} ${serviceName} does not exist. Creating it...`,
+            progressCallback
+          );
+          response = await runV1Client.namespaces.services.create({
+            parent,
+            requestBody: serviceConfig,
+          });
+        } else {
+          throw error;
+        }
+      }
+
+      await logAndProgress(
+        `${type.charAt(0).toUpperCase() + type.slice(1)} ${serviceName} deployed successfully.`,
+        progressCallback
+      );
+
+      // Set public access if skipIamCheck is enabled
+      try {
+        if (skipIamCheck) {
+          await setServicePublicAccess(
+            projectId,
+            region,
+            serviceName,
+            accessToken,
+            progressCallback
+          );
+        }
+      } catch (error) {
+        await logAndProgress(
+          `Failed to set public access for ${type} ${serviceName}: ${error.message}`,
+          progressCallback,
+          'warn'
+        );
+      }
+      if (type === 'service') {
+        const deployedService = response.data || response;
+        const serviceUrl = deployedService.status?.url;
+
+        deploymentResults['service'] = serviceName;
+        deploymentResults['uri'] = serviceUrl;
+      }
+    }
+    await logAndProgress(
+      `Deployment (compose) completed successfully. Deployment results: ${JSON.stringify(deploymentResults)}`,
+      progressCallback
+    );
+    return deploymentResults;
+  } catch (error) {
+    const errorMsg = `Deployment (compose) failed: ${error.message}`;
+    await logAndProgress(errorMsg, progressCallback, 'error');
+    throw error;
+  } finally {
+    if (tempDir) {
+      await cleanupTempDirectory(tempDir);
+    }
+  }
+}