@google-cloud/cloud-run-mcp 1.10.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,
@@ -43,6 +49,18 @@ import {
   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.
@@ -69,7 +87,8 @@ async function deployToCloudRun(
   deploymentType,
   accessToken,
   zippedSourceContainer,
-  runtime
+  runtime,
+  ingress
 ) {
   const runClient = await getRunClient(projectId, accessToken);
   const parent = runClient.locationPath(projectId, location);
@@ -91,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) {
@@ -249,7 +272,8 @@ async function deployWithZip(
   deploymentAttrs,
   progressCallback,
   skipIamCheck,
-  accessToken
+  accessToken,
+  ingress
 ) {
   await logAndProgress(
     `Attempting direct source deployment...`,
@@ -292,10 +316,12 @@ async function deployWithZip(
       bucketName,
       region,
       accessToken,
+      undefined,
+      false,
       progressCallback
     );
 
-    await uploadToStorageBucket(
+    const file = await uploadToStorageBucket(
       bucket,
       archiveBuffer,
       archiveName,
@@ -304,7 +330,7 @@ async function deployWithZip(
     await logAndProgress('Source code uploaded successfully', progressCallback);
 
     const container = createDirectSourceDeploymentContainer({
-      bucketName,
+      bucketName: bucket.name,
       fileName: archiveName,
       deploymentAttrs,
     });
@@ -319,9 +345,14 @@ 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);
@@ -392,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}`;
 
@@ -401,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,
@@ -429,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;
@@ -448,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;
 }
 
@@ -474,6 +515,7 @@ export async function deploy({
   progressCallback,
   skipIamCheck,
   accessToken,
+  ingress,
 }) {
   if (!projectId) {
     const errorMsg =
@@ -482,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.';
@@ -500,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,
@@ -515,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 })) {
@@ -532,7 +587,8 @@ export async function deploy({
           deploymentAttrs,
           progressCallback,
           skipIamCheck,
-          accessToken
+          accessToken,
+          ingress
         );
       } catch (error) {
         await logAndProgress(
@@ -552,7 +608,8 @@ export async function deploy({
       bucketName,
       progressCallback,
       skipIamCheck,
-      accessToken
+      accessToken,
+      ingress
     );
   } catch (error) {
     const deployFailedMessage = `Deployment Failed: ${error.message}`;
@@ -582,6 +639,7 @@ export async function deployImage({
   progressCallback,
   skipIamCheck,
   accessToken,
+  ingress,
 }) {
   if (!projectId) {
     const errorMsg =
@@ -628,7 +686,10 @@ export async function deployImage({
       progressCallback,
       skipIamCheck,
       DEPLOYMENT_TYPES.IMAGE,
-      accessToken
+      accessToken,
+      undefined,
+      undefined,
+      ingress
     );
 
     await logAndProgress(`Deployment completed successfully`, progressCallback);
@@ -640,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);
+    }
+  }
+}

package/lib/deployment/helpers.js

@@ -15,8 +15,9 @@ limitations under the License.
 */
 
 import path from 'path';
-import fs from 'fs';
+import fs, { promises as fsPromises } from 'fs';
 import { DEPLOYMENT_CONFIG, RUNTIMES } from './constants.js';
+import { uploadToStorageBucket } from '../cloud-api/storage.js';
 
 /**
  * Checks if the input is a single folder path.
@@ -61,6 +62,30 @@ function checkIfDockerFileExists(files) {
   return false;
 }
 
+/**
+ * Checks if a compose file exists in the provided files array.
+ * @param {Array<string|Object>} files - An array of file paths or objects with filename properties.
+ * @returns {string|null} - Returns the path/filename of the compose file if found, null otherwise.
+ */
+function checkIfComposeFileExists(files) {
+  const composeFiles = [
+    'compose.yaml',
+    'compose.yml',
+    'docker-compose.yaml',
+    'docker-compose.yml',
+  ];
+  if (isFolder(files)) {
+    for (const name of composeFiles) {
+      const fullPath = path.join(files[0], name);
+      if (fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+  }
+  // TODO: we do not handle file content deployment at present as run-compose binary does not support it
+  return null;
+}
+
 /**
  * Checks if the provided folder appears to be a Node.js project.
  * It looks for a `package.json` file in the root of the first path in the `files` array.
@@ -132,6 +157,7 @@ function getDeploymentAttrs(files) {
 export function makeFileDeploymentMetadata(files) {
   return {
     hasDockerfile: checkIfDockerFileExists(files),
+    composeFilePath: checkIfComposeFileExists(files),
     deploymentAttrs: getDeploymentAttrs(files),
   };
 }
@@ -185,3 +211,34 @@ export function createDirectSourceDeploymentContainer({
 
   return container;
 }
+
+/**
+ * Uploads a local directory to a GCS bucket recursively.
+ * @param {*} bucket - GCS bucket object
+ * @param {string} localPath - Local directory path
+ * @param {string} gcsPrefix - GCS prefix (blob name starting part)
+ * @param {function} progressCallback - Callback for progress
+ */
+export async function uploadDirectory(
+  bucket,
+  localPath,
+  gcsPrefix,
+  progressCallback
+) {
+  const entries = await fsPromises.readdir(localPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(localPath, entry.name);
+    const destination = `${gcsPrefix}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await uploadDirectory(bucket, fullPath, destination, progressCallback);
+    } else {
+      const buffer = await fsPromises.readFile(fullPath);
+      await uploadToStorageBucket(
+        bucket,
+        buffer,
+        destination,
+        progressCallback
+      );
+    }
+  }
+}