Deploy the digdag helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy the Digdag Helm chart on OpenShift through Pulumi, you will need to first set up your OpenShift environment for Helm deployments. This typically involves having the Helm CLI installed and configured to communicate with your OpenShift cluster.

Pulumi supports Helm charts deployment on Kubernetes-based infrastructure including OpenShift. OpenShift is essentially Kubernetes with additional features, so the `kubernetes` package from Pulumi can be used to deploy Helm charts on it.

For this deployment, we'll use the `helm.sh/v3.Chart` resource from the `@pulumi/kubernetes` package. This resource represents a Helm chart in the Pulumi program and allows us to deploy applications to Kubernetes clusters, such as OpenShift, using Helm.

First, you need to make sure that your OpenShift cluster is up and that you have the necessary credentials (like `kubeconfig`) to access it. Pulumi uses these credentials to communicate with your cluster.

In the following TypeScript program, we will instantiate a `Chart` resource to deploy the Digdag Helm chart:

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

// Specify the namespace where Digdag will be installed. If not present, Pulumi will create it.
const namespace = new k8s.core.v1.Namespace("digdag-namespace", {
    metadata: {
        name: "digdag",
    },
});

// Define the Helm chart for Digdag.
const digdagChart = new k8s.helm.v3.Chart("digdag", {
    // Specify the namespace to deploy the chart into. This must match the created namespace object.
    namespace: namespace.metadata.name,
    // Replace with the repository that hosts the digdag chart.
    // For this example, we are assuming the chart is hosted at a location that requires no additional 
    // Helm repository setup. Otherwise, you may need to use the `repo` argument.
    chart: "digdag",
    // Specify the version of the Helm chart you wish to deploy.
    // It is a best practice to pin your chart version to avoid unintended updates.
    version: "x.y.z", // Replace with the actual chart version.
    // Additional values to configure Digdag, if necessary.
    values: {
        // Provide any specific configuration needed for the Digdag chart here.
    },
}, {
    // Associate dependencies; this ensures that the namespace will be created before the chart is applied.
    dependsOn: [namespace],
});

// Export the base URL for the Digdag server, which can be used to access the Digdag UI
// after deployment. This assumes that the Digdag chart creates a Service with type LoadBalancer
// or NodePort and that the service was given a name 'digdag-server' for this example.
export const digdagServerUrl = digdagChart.getResourceProperty("v1/Service", "digdag-server", "status").apply(status => {
    if (status.loadBalancer.ingress) {
        // LoadBalancer service type
        return `http://${status.loadBalancer.ingress[0].hostname}:${status.loadBalancer.ingress[0].port}`;
    } else {
        // NodePort service type (common in OpenShift clusters)
        // Export the NodePort and IP, specific command may vary based on your environment.
        // The user will have to construct the full URL manually.
        return {
            nodePort: status.nodePort,
            ingress: status.ingress,
        };
    }
});

```

This program defines a new Kubernetes namespace for the Digdag deployment and a Helm chart resource using the Digdag chart. Adjust the `chart`, `version` and `values` parameters to align with your specific setup.

The `dependsOn` option ensures that the namespace exists before the Helm chart is deployed. The `getResourceProperty` function attempts to fetch the service's external access endpoints once the service is up. Depending on your specific OpenShift configuration (which could use Routes for exposing services), you may need to adjust the exporting logic to fit your needs.

Make sure you have the Pulumi CLI installed and have authenticated with your Kubernetes/OpenShift cluster. To deploy this program, you would simply run `pulumi up` from the command line in the same directory as your program file. Pulumi would then perform the deployment, and if successful, output the base URL for the Digdag server once the service is exposed.

Remember that not all Helm charts provide a LoadBalancer or NodePort by default, and depending on your chart, you may have to customize the `values` field or the export logic to correctly expose your application's URL. Adjust the export section according to the actual service definition provided by the Digdag Helm chart.