Automate, Secure, and Manage Everything You Run in AWS with Pulumi

Experience the Future of Cloud Infrastructure Management

Welcome to the Pulumi booth #370 at AWS re:Invent! Discover how Pulumi and AWS are revolutionizing cloud infrastructure automation, security, and management for businesses like yours.

Engage with Pulumi at re:Invent

Don't miss these exciting opportunities to learn more and connect with our team. Visit booth #370 to see Pulumi in action, grab some swag, and discover how Pulumi and AWS together can turn your cloud into a powerful competitive advantage!

Schedule a 1:1 with Pulumi Leadership

Secure a private meeting with our Founder and top executives to gain exclusive insights on cloud strategy and innovation.

Request a Meeting
Schedule a 1:1 Pulumi Deep Dive

Get a personalized walkthrough on how to take your AWS infrastructure management to the next level with Pulumi.

Request a demo
Attend our AWS Workshop

Mastering AWS Infrastructure with Pulumi
Learn hands-on techniques to supercharge your AWS deployments using Pulumi.

REGISTER
RSVP to 1923 at re:Invent

Join Pulumi Partners Honeycomb, BuildKite, Oso and observeIQ
Wednesday, December 4
8:00 - 11:00 pm

Top Golf Experience

Unwind with your favorite re:Invent attendees at Top Golf
Wednesday, December 4
5:00 - 8:00 pm

Reserve your Bay
import * as eks from "@pulumi/eks";

 // Create an EKS cluster.
 const cluster = new eks.Cluster("cluster", {
     instanceType: "t2.medium",
     desiredCapacity: 2,
     minSize: 1,
     maxSize: 2,
 });

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

import pulumi
import pulumi_eks as eks

# Create an EKS cluster.
cluster = eks.Cluster(
    "cluster",
    instance_type="t2.medium",
    desired_capacity=2,
    min_size=1,
    max_size=2,
)

# Export the cluster's kubeconfig.
pulumi.export("kubeconfig", cluster.kubeconfig)

package main

import (
    "github.com/pulumi/pulumi-eks/sdk/go/eks/cluster"
    "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
    // Create an EKS cluster.
    cluster, err := cluster.NewCluster(ctx, "cluster",
        cluster.ClusterArgs{
            InstanceType:    pulumi.String("t2.medium"),
            DesiredCapacity: pulumi.Int(2),
            MinSize:         pulumi.Int(1),
            MaxSize:         pulumi.Int(2),
        },
    )
    if err != nil {
        return err
    }

    // Export the cluster's kubeconfig.
    ctx.Export("kubeconfig", cluster.Kubeconfig)

    return nil
    })
}

using System;
using System.Threading.Tasks;
using Pulumi;
using Pulumi.Eks.Cluster;

class EksStack : Stack
{
    public EksStack()
    {
        // Create an EKS cluster.
        var cluster = new Cluster("cluster", new ClusterArgs
        {
            InstanceType = "t2.medium",
            DesiredCapacity = 2,
            MinSize = 1,
            MaxSize = 2,
        });

        // Export the cluster's kubeconfig.
        this.Kubeconfig = cluster.Kubeconfig;
    }

    [Output("kubeconfig")]
    public Output<string> Kubeconfig { get; set; }
}

class Program
{
    static Task<int> Main(string[] args) => Deployment.RunAsync<EksStack>();
}

package com.pulumi.example.eks;

import com.pulumi.Context;
import com.pulumi.Exports;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.eks.Cluster;
import com.pulumi.eks.ClusterArgs;

import java.util.stream.Collectors;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    private static Exports stack(Context ctx) {
        var cluster = new Cluster("my-cluster", ClusterArgs.builder()
                .instanceType("t2.micro")
                .desiredCapacity(2)
                .minSize(1)
                .maxSize(2)
                .build());

        ctx.export("kubeconfig", cluster.kubeconfig());
        return ctx.exports();
    }
}

name: aws-eks
runtime: yaml
description: An EKS cluster
resources:
    cluster:
        type: eks:Cluster
        properties:
            instanceType: "t2.medium"
            desiredCapacity: 2
            minSize: 1
            maxSize: 2
outputs:
    kubeconfig: ${cluster.kubeconfig}

Pulumi + AWS: Better Together

Ship faster, secure your secrets, and enforce cloud compliance and security with Pulumi IaC (infrastructure as code), ESC (secrets management and orchestration), and Insights (cloud asset and compliance management). Our partnership with AWS offers a robust solution for complex cloud deployments, enabling you to:

Automate your AWS infrastructure with Pulumi IaC.

Build and ship infrastructure faster using languages you know and love, like TypeScript, Python, Go, C#, and Java.

Secure your cloud secrets with Pulumi ESC.

Centrally manage all your secrets and configurations. Pull and sync secrets with any secrets store. Consume in any application, tool, or CI/CD platform.

Manage your AWS resources with Pulumi Insights.

Search, compliance remediation, resource visualizations, cost optimization, and AI insights over all your AWS infrastructure.

Virtual Developer Communities

Connect with us. Ask questions, find answers, and share your knowledge and grow with us.

Search for an answer
Ask a question
Contribute to Pulumiverse
 Twitter
 LinkedIn
 YouTube
 GitHub