Deploy the ibm-license-service-instance helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the IBM License Service Chart on AWS EKS using Pulumi, we will perform the following steps:

1. Create an EKS Cluster: This is the Kubernetes cluster provided by AWS where our Helm chart will be deployed.
2. Define an ECR Repository: Amazon's Elastic Container Registry to store our Docker images if needed.
3. Associate IAM Roles: For the EKS cluster to have the right permissions.
4. Deploy Helm Chart: This will deploy the IBM License Service Helm chart into our EKS cluster.

We'll use the Pulumi Kubernetes package to define the Helm chart deployment and use the AWS EKS package for provisioning the EKS cluster. We will also use the `awsx` package for higher-level components that simplify EKS cluster creation.

Here is a sample TypeScript program using Pulumi to complete the deployment:

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

// Create an EKS cluster.
// More information on creating an EKS cluster can be found here:
// https://www.pulumi.com/registry/packages/aws/api-docs/eks/cluster/
const cluster = new eks.Cluster("my-cluster", {
    vpcId: awsx.ec2.Vpc.getDefault().id,
    subnetIds: awsx.ec2.Vpc.getDefault().publicSubnetIds,
    instanceType: "t2.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
    storageClasses: "gp2",
    deployDashboard: false,
});

// Export the cluster's kubeconfig.
export const kubeconfig = cluster.kubeconfig;

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

// Deploy the IBM License Service Helm chart into our EKS cluster.
// Information on deploying Helm charts can be found here:
// https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/
const ibmLicenseServiceChart = new k8s.helm.v3.Chart("ibm-license-service", {
    chart: "ibm-license-service-instance",
    // Note: You will need to specify the correct repository or chart URL here.
    // The version, values, and namespace may also need to be set depending on the chart's requirements.
    version: "1.0.0", // replace with the correct chart version
    fetchOpts: {
        repo: "https://charts.your-repository.com/", // replace with the correct repository URL
    },
}, { provider });

// Export the URL to access the deployed IBM License Service application (if applicable).
// This will vary based on the service and ingress configuration in your Helm chart.
export const ibmLicenseServiceUrl = pulumi.interpolate `http://${cluster.endpoint}`;
```

In the above program:

- We create an EKS cluster with desired configuration using `@pulumi/eks`. This sets up the basic infrastructure to run our Kubernetes services.
- We define a Kubernetes provider that specifies the kubeconfig of the EKS cluster so that Pulumi knows how to communicate with our Kubernetes cluster.
- We deploy the "ibm-license-service-instance" Helm chart. We specify the `chart` and `version` according to the chart details. The `fetchOpts.repo` must point to the Helm repository that hosts the IBM License Service Chart.
- The `kubeconfig` of the cluster is exported so that you can interact with your Kubernetes cluster using `kubectl` or other Kubernetes tools.
- If your Helm chart defines a service with an external endpoint (via a LoadBalancer, NodePort, or Ingress), you may export its URL. However, the given template uses the cluster's endpoint for an example, and the actual URL will vary based on your Helm chart's configuration.

This program needs to be modified with the correct chart version, repository URL, instance types, and any other specifics related to the Helm chart's configuration. Once you have that information and have configured your Pulumi account and AWS credentials, you can run this program using the Pulumi CLI to deploy to AWS EKS.