Deploy the gitea-instance helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the Gitea Helm chart on Google Kubernetes Engine (GKE), you'll need to perform the following steps:

1. Create a GKE cluster: You'll need a Kubernetes cluster running on GKE where you can deploy the Gitea instance. This can be done using Pulumi's `gcp.container.Cluster` resource.
2. Install and configure Helm: Helm is a package manager for Kubernetes, which allows for easy installation and management of applications. Pulumi can manage Helm releases directly through the `kubernetes.helm.v3.Chart` class.
3. Deploy the Gitea Helm chart: Once you have a running GKE cluster and Helm is set up, you can then use Pulumi to deploy the Gitea Helm chart to your cluster.

Below is a Pulumi program written in TypeScript that completes these steps:

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

// Step 1: Create a new GKE cluster
const cluster = new gcp.container.Cluster("gitea-cluster", {
    initialNodeCount: 1,
    minMasterVersion: "latest", // Use the latest available version of GKE
    nodeConfig: {
        machineType: "n1-standard-1", // Adjust machine type as necessary
        oauthScopes: [
            "https://www.googleapis.com/auth/compute", // Scope for compute API
            "https://www.googleapis.com/auth/devstorage.read_only", // Scope for storage in read-only mode
            "https://www.googleapis.com/auth/logging.write", // Scope for logging write access
            "https://www.googleapis.com/auth/monitoring", // Scope for monitoring
        ],
    },
});

// Export the Cluster name and Kubeconfig
export const clusterName = cluster.name;
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
`;
    });

// Step 2: Configure Kubernetes provider to use the created GKE cluster
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeConfig,
});

// Step 3: Deploy Gitea Helm chart into the GKE cluster using the configured provider
const giteaChart = new k8s.helm.v3.Chart("gitea", {
    chart: "gitea",
    fetchOpts:{
        repo: "https://dl.gitea.io/charts/", // Gitea's Helm repository
    },
    // You can include additional configuration for Gitea here using `values` or by creating a values.yaml file
}, { provider: k8sProvider });

// Export the Gitea service endpoint
export const giteaEndpoint = giteaChart.getResourceProperty("v1/Service", "gitea-http", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Let's break down what the code above does:

- **GKE Cluster**: We create a GKE cluster with a single node and specify the machine type and scopes required for the node. This sets up the compute environment where Gitea will run.
- **Exporting Configurations**: We construct a kubeconfig file that Pulumi’s Kubernetes provider can use to communicate with the GKE cluster. We then export the cluster name and the kubeconfig string so it can be easily accessed if needed.
- **Kubernetes Provider Configuration**: We set up a Kubernetes provider to interact with our GKE cluster. The provider will be used by Pulumi to manage Kubernetes resources in our newly created cluster.
- **Gitea Helm Chart**: Deploy a Gitea Helm chart from Gitea's official Helm chart repository. Simply specifying the chart name and the repository will pull the chart and install it on the cluster.
- **Exporting Gitea Endpoint**: Finally, we export the IP of the load balancer created by the Gitea Helm chart. This is the IP address that you can use to access your Gitea instance from a web browser.

To use the program:

1. Install [Pulumi](https://www.pulumi.com/docs/get-started/install/) and set up the [GCP provider](https://www.pulumi.com/docs/intro/cloud-providers/gcp/setup/).
2. Set up [Helm](https://www.pulumi.com/docs/intro/cloud-providers/kubernetes/#helm).
3. Run `pulumi up` to deploy your Gitea instance to GKE.

Once the deployment is successful, you will see the Gitea service endpoint in the Pulumi stack outputs. Use this IP address in a web browser to access your Gitea instance.