Automating Kubernetes deployments with Argo CD

Question

Pulumi · Accepted Answer

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. It automates the deployment of applications to Kubernetes by using Git repositories as the source of truth for defining the desired application state.

To automate Kubernetes deployments with Argo CD using Pulumi, the typical steps are as follows:

1. **Define the desired state of your applications**: You should define your application's Kubernetes resources (e.g., Deployments, Services, Ingress, etc.) in a Git repository in the form of manifests or Helm charts.

2. **Install Argo CD**: You need an Argo CD instance running in your Kubernetes cluster. It will monitor your Git repos and ensure that your Kubernetes cluster's state matches the desired state defined in Git.

3. **Register the Git repositories with Argo CD**: This involves setting up Argo CD `Application` resources that point to the paths in your Git repositories where your Kubernetes manifests are stored.

4. **Observation and synchronization**: Argo CD will continuously observe the registered Git repository. Whenever changes are committed, Argo CD compares the current cluster state with the new desired state and applies the changes to the cluster to synchronize them.

In this TypeScript program with Pulumi, we'll focus on steps 3 and 4: how to define an Argo CD `Application` resource that points to a Git repository with your application's Kubernetes manifests. Before running this code, you should have a Kubernetes cluster and Argo CD installed in it.

Below is a Pulumi program that creates an Argo CD `Application` resource, which monitors a Git repository for changes and ensures your Kubernetes cluster is synced with the state defined in the repository.

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

// The Application resource is what Argo CD uses to manage the deployment and syncing of your application
// from the git repository to the Kubernetes cluster. Here we're creating an Application resource
// which will point to a public GitHub repository containing a sample guestbook application.

const appLabels = { app: "guestbook" };

const guestbookApp = new kubernetes.apiextensions.CustomResource(
    "guestbook-app",
    {
        // You must define the apiVersion and kind of the CustomResource according to the kind of Kubernetes resource you're creating.
        apiVersion: "argoproj.io/v1alpha1",
        kind: "Application",
        metadata: {
            // The name of the resource in Kubernetes - typically this will match the name of your app/service.
            name: "guestbook",
            namespace: "argocd", // Namespace to deploy the resource in - this should be the namespace where Argo CD is running.
        },
        spec: {
            // The project in Argo CD to which this Application belongs.
            project: "default",

// Defining the source of the Kubernetes manifests. In this case, it's a public GitHub repository.
            source: {
                repoURL: "https://github.com/argoproj/argocd-example-apps.git",
                targetRevision: "HEAD", // The branch, tag, or commit to sync to
                path: "guestbook", // Directory path within the Git repository to find manifests
            },

// Defining the destination where these manifests will be applied. It can be your local cluster or any external one.
            destination: {
                server: "https://kubernetes.default.svc", // The API server URL - 'kubernetes.default.svc' will assume the same cluster as Argo CD
                namespace: "guestbook", // Namespace in the Kubernetes cluster to deploy these manifests
            },

// Define the synchronization policy - in this case, it's automated with auto-creation of the namespace and pruning enabled.
            syncPolicy: {
                automated: {
                    prune: true,       // Prune resources not in git
                    selfHeal: true,    // Heal the cluster to match git
                    allowEmpty: false, // Fail if the directory is empty
                },
            },
        },
    },
    {
        provider: argoCdProvider, // A Pulumi Kubernetes Provider connected to the Argo CD API endpoint
    }
);

export const guestbookAppName = guestbookApp.metadata.name;
```

Here, we declare a new `CustomResource` of kind `Application`, which Argo CD recognizes as an application to be managed. Note that you must have the `argoproj.io/v1alpha1` Custom Resource Definition (CRD) installed in your cluster, which is typically installed as part of Argo CD.

We define a public repository that contains the `guestbook` application. Argo CD will track the `HEAD` of the master branch of this repository and apply any changes found in the `guestbook` directory within that repository.

In the `destination` field, we specify our local Kubernetes cluster and the `guestbook` namespace as the target for the deployment.

The `syncPolicy` is set to `automated`, meaning Argo CD will automatically apply any changes it detects in the Git repository to the Kubernetes cluster and will prune any resources that are no longer in the repository.

In order to run this Pulumi program, you will need to have Pulumi installed and configured for your Kubernetes cluster. You should also have Argo CD installed in your cluster with a `default` project created.

After running `pulumi up` with this Pulumi code, you'll have an Argo CD Application resource that automatically syncs your guestbook app from the specified Git repository to your Kubernetes cluster.

Please note that this code assumes you have a specific provider for Argo CD if your API is exposed externally. Otherwise, you may use the default provider to communicate with resources within the Kubernetes cluster where Pulumi is running. If you have specific requirements such as private Git repositories or custom synchronization policies, you'll need to adjust the `source` and `syncPolicy` fields accordingly.