@chimoney.io/iaas-k8s-deployment/dist/src/core/aws-infra.js

Kubernetes Infrastructure as a Service deployment package for streamlined multi-cloud environments

import * as awsx from "@pulumi/awsx";
import * as eks from "@pulumi/eks";
import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi"; // Added for pulumi.log
const devConfig = {
    instanceType: "t3.medium",
    desiredCapacity: 2,
    minSize: 1,
    maxSize: 3,
};
const prodConfig = {
    instanceType: "m5.large", // Larger instance type for production
    desiredCapacity: 3, // More nodes for production
    minSize: 2,
    maxSize: 5,
};
// Function to create an EKS cluster
export function createEksCluster(name, stack) {
    const config = stack === "prod" ? prodConfig : devConfig;
    pulumi.log.info(`Using ${stack} configuration for EKS cluster. Instance type: ${config.instanceType}`);
    // Create a VPC for our cluster.
    const vpc = new awsx.ec2.Vpc(`${name}-vpc`, {
        numberOfAvailabilityZones: 2, // Configure as needed
    });
    // Create an EKS cluster with the default configuration.
    const cluster = new eks.Cluster(`${name}-cluster`, {
        vpcId: vpc.vpcId,
        subnetIds: vpc.privateSubnetIds, // Use private subnets for EKS workers
        instanceType: config.instanceType, // Use stack-specific instance type
        desiredCapacity: config.desiredCapacity, // Use stack-specific desired capacity
        minSize: config.minSize, // Use stack-specific min size
        maxSize: config.maxSize, // Use stack-specific max size
        storageClasses: "gp2", // Default storage class
    });
    return {
        kubeconfig: cluster.kubeconfig,
        vpcId: vpc.vpcId,
        clusterName: cluster.eksCluster.name, // Export the EKS cluster name
        region: aws.getRegion().then((r) => r.name),
    };
}
// Function to look up existing shared EKS cluster (using Pulumi data sources)
export function lookupSharedEksClusterSync(sharedClusterName) {
    const region = aws.getRegion().then((r) => r.name);
    // Look for existing EKS cluster using Pulumi data source
    const clusterLookup = aws.eks
        .getCluster({
        name: sharedClusterName,
    }, { async: true })
        .then((existingCluster) => {
        if (existingCluster) {
            pulumi.log.info(`Found existing shared EKS cluster: ${sharedClusterName}`);
            // Generate kubeconfig for existing cluster
            const kubeconfig = `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${existingCluster.certificateAuthorities?.[0]?.data}
    server: ${existingCluster.endpoint}
  name: ${sharedClusterName}
contexts:
- context:
    cluster: ${sharedClusterName}
    user: ${sharedClusterName}
  name: ${sharedClusterName}
current-context: ${sharedClusterName}
kind: Config
preferences: {}
users:
- name: ${sharedClusterName}
  user:
    exec:
      apiVersion: client.authentication.k8s.io/v1beta1
      command: aws
      args:
        - eks
        - get-token
        - --cluster-name
        - ${sharedClusterName}
        - --region
        - ${region}`;
            return {
                exists: true,
                kubeconfig: kubeconfig,
                clusterName: existingCluster.name,
                region: region,
            };
        }
        else {
            return {
                exists: false,
            };
        }
    })
        .catch(() => {
        pulumi.log.info(`Shared EKS cluster ${sharedClusterName} not found, will create new one`);
        return {
            exists: false,
        };
    });
    return pulumi.output(clusterLookup);
}
//# sourceMappingURL=aws-infra.js.map