Deploy the nagios helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Nagios Helm chart on Google Kubernetes Engine (GKE), you will need to perform several steps. Here's a general overview:

1. **Set up a GKE cluster**: First, you'll need a Kubernetes cluster running on GKE. 
2. **Configure Helm in your cluster**: Helm is a package manager for Kubernetes that simplifies deployment.
3. **Deploy the Nagios Helm chart**: Once Helm is set up, you can deploy Nagios using a Helm chart.

Below is a detailed Pulumi program written in TypeScript that demonstrates how to accomplish these tasks.

First, make sure that you have:
- **Installed Pulumi CLI**: Follow the [installation guide](https://www.pulumi.com/docs/get-started/install/).
- **Installed `kubectl`**: The Kubernetes command-line tool, which you can install from the [official documentation](https://kubernetes.io/docs/tasks/tools/).
- **Installed Helm CLI**: The Helm package manager for Kubernetes, which you can install from the [Helm documentation](https://helm.sh/docs/intro/install/).

Now follow these steps to create the infrastructure:

### Set up GKE Cluster

We use the `gcp.container.Cluster` resource to create a GKE cluster. A node pool is automatically created with this cluster, but you can customize it as needed.

### Configure Kubernetes Provider

Once we have the cluster, we then configure the Kubernetes provider to use the credentials from the GKE cluster, allowing Pulumi to deploy resources to it.

### Deploy Nagios Helm Chart

For deploying Nagios, we use the `kubernetes.helm.v3.Chart` resource, which allows us to specify the Helm chart we want to deploy (in this case, the Nagios chart). We can customize the settings for the chart by passing values to the `values` property.

Now let's look at the Pulumi TypeScript program:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
        ],
    },
});

// Export the Kubeconfig to access the GKE cluster using kubectl.
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy Nagios Helm chart into the GKE cluster using the Kubernetes provider.
const nagiosChart = new k8s.helm.v3.Chart("nagios", {
    fetchOpts:{
        repo: "https://prometheus-community.github.io/helm-charts",
    },
    chart: "nagios",
    version: "0.2.2", // Specify the version of the chart if needed.
    values: {
        // Customize your Nagios deployment here.
    },
}, { provider: k8sProvider });

// Export the Nagios service endpoint to access the dashboard.
export const nagiosDashboard = nagiosChart.getResourceProperty("v1/Service", "nagios-nagios", "status")
    .apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);
```

This program does the following:
- Provisions a new GKE cluster with the specified settings.
- Generates a kubeconfig file needed to connect to the GKE cluster.
- Configures the Kubernetes provider to manage the newly created cluster.
- Deploys the Nagios application using a Helm chart to the cluster, and you can define the specific version of the chart you want to deploy.
- Exports the URL needed to access the Nagios dashboard once it's up and running.

Please ensure to replace any placeholders or add additional configuration according to your needs, particularly within the Helm chart values.

After writing your Pulumi code, run the following commands in your terminal to deploy the resources:

```bash
pulumi up
```

Make sure you’re logged into the GCP CLI (`gcloud`) and set the correct project and compute zone that you’re working with. After running the `pulumi up` command, you will see a list of resources that Pulumi will create. Confirm the operation, and Pulumi will begin provisioning the infrastructure.

Once the operation is successful, you can grab the IP address or hostname of the Nagios service endpoint, as exported by the `nagiosDashboard`, and navigate to it in your web browser to access the Nagios dashboard.