Scaling deployments using Argo Rollouts analysis

Question

Pulumi · Accepted Answer

Argo Rollouts is a Kubernetes controller and set of CRDs which provide advanced deployment capabilities such as blue-green and canary deployments. To use Argo Rollouts, you typically define a `Rollout` resource that specifies the deployment strategy and the desired states for different rollout stages.

Here's an introduction to creating a basic Argo Rollout using Pulumi and TypeScript. This program will set up a Kubernetes cluster (assuming you have the necessary cloud provider setup outside of this script) and deploy an application with a simple canary deployment strategy using Argo Rollouts.

To start, you'll need to install the necessary Pulumi packages for Kubernetes if you haven't already:

```bash
npm install @pulumi/kubernetes
```

Moreover, suppose you already have Argo Rollouts installed in your cluster. If not, you can also install it using Pulumi, but this program assumes its presence.

Now, let's jump into the Pulumi program:

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

// Create a Kubernetes Namespace for your application and Argo Rollouts resources.
const namespace = new k8s.core.v1.Namespace("argo-rollouts-namespace", {
    metadata: {
        name: "argo-rollouts",
    }
});

// Define a Kubernetes deployment using Argo Rollouts.
const rollout = new k8s.apiextensions.CustomResource("argo-rollout", {
    apiVersion: "argoproj.io/v1alpha1",
    kind: "Rollout",
    metadata: {
        namespace: namespace.metadata.name, // Using the namespace created above.
        name: "example-rollout", // Name of the Rollout resource.
    },
    spec: {
        selector: {
            matchLabels: {
                app: "example" // Labels used to track your pods.
            }
        },
        template: {
            metadata: {
                labels: {
                    app: "example" // Labels that will be applied to the pods.
                }
            },
            spec: {
                containers: [{
                    name: "app",
                    image: "nginx:1.19.3", // Container image to deploy.
                    ports: [{containerPort: 80}] // Port on which the container is listening.
                }]
            }
        },
        strategy: {
            // Define the strategy as canary. You could also use blue-green.
            canary: {
                steps: [
                    { setWeight: 20 }, // Shift 20% of traffic to the canary version.
                    { pause: { duration: "30s" } }, // Pause for assessment.
                    { setWeight: 40 }, // Shift 40% of traffic to the canary version.
                    { pause: { duration: "30s" } }, // Pause for further assessment.
                    // Add additional steps as necessary.
                ]
            }
        },
        // Number of replicas for the deployment.
        replicas: 3,
    }
}, { dependsOn: [namespace] }); // Ensure the namespace is created before the Rollout.

// Export the namespace name and Rollout name so they can be easily accessed.
export const namespaceName = namespace.metadata.name;
export const rolloutName = rollout.metadata.name;
```

In this TypeScript program for Pulumi, here's what we've done:

1. **Created a namespace**: A new namespace called `argo-rollouts` is created to house our Rollout and avoid cluttering the default namespace.

2. **Defined the Rollout resource**: We declare a `Rollout` resource with a canary deployment strategy. The Rollout resource specifies the number of replicas, which container image to use (`nginx` in this case), and defines the steps for transitioning traffic to the new version.

3. **Configured the canary strategy**: A series of steps are defined for the canary update. Initially, 20% of the traffic is sent to the new version, after which there is a pause for validation before proceeding to send 40% of the traffic.

4. **Exports**: The name of the namespace and the name of the Rollout are exported to allow querying afterward using `pulumi stack output`.

This is a basic introduction. Argo Rollouts supports more sophisticated strategies and functionality that you can leverage as per your requirements.

Finally, to apply this configuration in your Kubernetes cluster, save the script as `index.ts` and run the following Pulumi commands:

```bash
pulumi stack init dev
pulumi up
```

Make sure you have Pulumi installed and configured to communicate with your Kubernetes cluster. The `pulumi up` command will provision the resources defined in the script on your cluster.