Using gcp artifactregistry with clouddeploy

Question

Pulumi · Accepted Answer

In Google Cloud Platform, Google Cloud Artifact Registry is a single place for your organization to manage artifacts and build dependencies. It allows you to manage Docker images, Maven packages, npm packages, and other artifact types.

When using Artifact Registry with Cloud Deploy, the typical workflow would involve the following:

1. A source code repository that triggers a CI/CD pipeline on changes.
2. A build step that creates an artifact (Docker image, JAR file, etc.)
3. Pushing the artifact to Artifact Registry.
4. Deploying the artifact using Google Cloud Deploy, which orchestrates and automates the deployment of applications to Google Kubernetes Engine (GKE), Cloud Run, or Anthos.

I’ll guide you through setting up an Artifact Registry repository and using it with Cloud Deploy using Pulumi.

### Step 1: Create an Artifact Registry Repository

First, we need to create a repository in Google Cloud Artifact Registry to store our artifacts. Here we will create a Docker repository, but you can adjust the format for other types of artifacts such as `MAVEN` or `NPM`.

### Step 2: Set Up Cloud Deploy Targets

A target in Cloud Deploy refers to the location where the application will be deployed. This can be a GKE cluster, a Cloud Run service, or an Anthos cluster.

### Step 3: Create a Cloud Deploy Delivery Pipeline

A delivery pipeline in Cloud Deploy manages the sequence of stages required to deploy your application, such as testing, canary, and production stages.

Below is a Pulumi TypeScript program that sets up these resources:

```typescript
import * as gcp from "@pulumi/gcp";

// Replace these variables with your specific details
const projectName = "your-gcp-project";
const location = "us-central1"; // Choose the right location for your resources
const repositoryId = "my-docker-repo";
const targetName = "my-deployment-target";
const pipelineName = "my-delivery-pipeline";

// Step 1: Create an Artifact Registry Repository
const artifactRepository = new gcp.artifactregistry.Repository(repositoryId, {
  location,
  format: "DOCKER",
  repositoryId,
  // Optional: Add other configurations like description, labels, etc.
});

// Step 2: Set Up Cloud Deploy Target
const deployTarget = new gcp.clouddeploy.Target(targetName, {
  name: targetName,
  location,
  project: projectName,
  // Define the specific configurations depending on your deploy target.
  // This example assumes GKE, but you may configure Cloud Run or Anthos.
  gke: {
    cluster: "projects/project-id/locations/gke-region/clusters/cluster-name",
  },
  // Optional: Add other configurations like labels, description, requireApproval, etc.
});

// Step 3: Create a Cloud Deploy Delivery Pipeline
const deliveryPipeline = new gcp.clouddeploy.DeliveryPipeline(pipelineName, {
  name: pipelineName,
  location,
  project: projectName,
  // Define the stages of your pipeline.
  serialPipeline: {
    stages: [
      {
        targetId: deployTarget.id,
        // Optional: Define profiles, strategies, targets, deploy parameters, etc.
      },
      // Add more stages as required
    ],
  },
  // Optional: Add other configurations like labels, annotations, description, etc.
});

// Optional: Output the generated artifact repository URL.
export const repositoryUrl = artifactRepository.url;
```

### Explanation:

- `@pulumi/gcp`: We import the GCP package to interact with Google Cloud services.
- `artifactRegistry`: We create a Docker repository named _my-docker-repo_ in the location _us-central1_.
- `deployTarget`: We create a deployment target for our pipeline. The example assumes a GKE cluster but can be modified for other platforms like Cloud Run or Anthos by adjusting the configurations.
- `deliveryPipeline`: We create a delivery pipeline with a single target. You can add more stages depending on your deployment processes, like a staging environment before production.
- `export`: The `export` at the end of the program is a Pulumi feature to output the URL of the created Artifact Registry repository for easy access.

Please note that you need to replace placeholders with your actual project details where indicated. Also, this is just a basic example. Depending on your actual use case, you might need to add more configuration, like IAM policies, network settings, or enabling specific services.

Keep in mind this is a simplified version of what could be a more complex deployment. In a real-world scenario, you'd also set up CI/CD pipelines using tools like Cloud Build, Jenkins, or GitLab to trigger builds and deployments automatically.