Ctrl + k

or run

tessl search

Version

Workspace: tessl
Visibility: Public
Created: about 4 hours ago
Last updated: about 4 hours ago
Describes: pkg:maven/com.pulumi/aws@7.16.x

tessl/maven-com-pulumi--aws

tessl install tessl/maven-com-pulumi--aws@7.16.0

Pulumi Java SDK for AWS providing strongly-typed Infrastructure-as-Code for 227 AWS service packages including compute, storage, databases, networking, security, analytics, machine learning, and more.

Getting Started with Pulumi AWS Java SDK

This guide will help you get started with the Pulumi AWS Java SDK for Infrastructure-as-Code.

Prerequisites

Java 11 or later installed
Maven or Gradle for dependency management
Pulumi CLI installed (installation guide)
AWS credentials configured (AWS CLI setup)

Installation

Maven

Add the dependency to your pom.xml:

<dependencies>
    <dependency>
        <groupId>com.pulumi</groupId>
        <artifactId>pulumi</artifactId>
        <version>0.13.0</version>
    </dependency>
    <dependency>
        <groupId>com.pulumi</groupId>
        <artifactId>aws</artifactId>
        <version>7.16.0</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.2</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.example.App</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

Gradle

Add to your build.gradle:

plugins {
    id 'java'
    id 'application'
}

dependencies {
    implementation 'com.pulumi:pulumi:0.13.0'
    implementation 'com.pulumi:aws:7.16.0'
}

application {
    mainClass = 'com.example.App'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
}

AWS Credentials Configuration

The Pulumi AWS provider uses the standard AWS credential resolution chain:

Environment variables: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN
Shared credentials file: ~/.aws/credentials
IAM role (when running on EC2 or ECS)

Option 1: Using AWS CLI Configuration

aws configure

This creates ~/.aws/credentials and ~/.aws/config files.

Option 2: Using Environment Variables

export AWS_ACCESS_KEY_ID="your-access-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
export AWS_REGION="us-west-2"

Option 3: Using Named Profiles

In your Pulumi program:

import com.pulumi.aws.Provider;
import com.pulumi.aws.ProviderArgs;

var awsProvider = new Provider("aws", ProviderArgs.builder()
    .region("us-west-2")
    .profile("my-profile")
    .build());

Creating Your First Pulumi Project

Step 1: Initialize a New Project

mkdir my-aws-infrastructure
cd my-aws-infrastructure
pulumi new java

Follow the prompts to set up your project.

Step 2: Create a Simple Resource

Edit src/main/java/myproject/App.java:

package myproject;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketArgs;

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

    public static void stack(Context ctx) {
        // Create an S3 bucket
        var bucket = new Bucket("my-first-bucket", BucketArgs.builder()
            .bucket("my-unique-bucket-name-12345")
            .build());

        // Export the bucket name
        ctx.export("bucketName", bucket.bucket());
        ctx.export("bucketArn", bucket.arn());
    }
}

Step 3: Preview and Deploy

Preview the changes:

pulumi preview

Deploy the infrastructure:

pulumi up

Type "yes" to confirm the deployment.

Step 4: View Outputs

After deployment, view the stack outputs:

pulumi stack output bucketName
pulumi stack output bucketArn

Step 5: Clean Up

Destroy the resources when done:

pulumi destroy

Understanding the Basic Structure

Main Application Entry Point

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

    public static void stack(Context ctx) {
        // Your infrastructure code here
    }
}

Pulumi.run() is the entry point for the Pulumi runtime
stack() method contains your infrastructure definitions
Context ctx provides stack context and export capabilities

Resource Creation Pattern

var resource = new ResourceType("resource-name", ResourceTypeArgs.builder()
    .property1(value1)
    .property2(value2)
    .build());

First argument is the resource name (unique within the stack)
Second argument is the configuration using builder pattern
Returns a resource object with output properties

Working with Outputs

// Resource properties are Output<T>
Output<String> bucketName = bucket.bucket();
Output<String> bucketArn = bucket.arn();

// Transform outputs with apply()
Output<String> upperName = bucketName.apply(String::toUpperCase);

// Combine multiple outputs
Output<String> combined = Output.tuple(bucket.bucket(), bucket.arn())
    .apply(tuple -> tuple.t1 + " - " + tuple.t2);

// Export outputs (visible in pulumi stack output)
ctx.export("bucketName", bucketName);

Resource Dependencies

Pulumi automatically tracks dependencies when you pass Output values:

// Create VPC
var vpc = new Vpc("my-vpc", VpcArgs.builder()
    .cidrBlock("10.0.0.0/16")
    .build());

// Create subnet (depends on VPC automatically)
var subnet = new Subnet("my-subnet", SubnetArgs.builder()
    .vpcId(vpc.id())  // Dependency is tracked here
    .cidrBlock("10.0.1.0/24")
    .build());

Common First Projects

Example 1: Static Website with S3

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.aws.s3.*;
import com.pulumi.asset.FileAsset;
import java.util.Map;

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

    public static void stack(Context ctx) {
        // Create bucket
        var bucket = new Bucket("website-bucket", BucketArgs.builder()
            .website(BucketWebsiteArgs.builder()
                .indexDocument("index.html")
                .build())
            .build());

        // Make bucket public
        new BucketPublicAccessBlock("public-access", BucketPublicAccessBlockArgs.builder()
            .bucket(bucket.id())
            .blockPublicAcls(false)
            .blockPublicPolicy(false)
            .ignorePublicAcls(false)
            .restrictPublicBuckets(false)
            .build());

        // Upload index.html
        new BucketObject("index", BucketObjectArgs.builder()
            .bucket(bucket.id())
            .key("index.html")
            .source(new FileAsset("index.html"))
            .contentType("text/html")
            .acl("public-read")
            .build());

        ctx.export("websiteUrl", bucket.websiteEndpoint());
    }
}

Example 2: EC2 Instance with Security Group

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.aws.ec2.*;
import com.pulumi.aws.ec2.inputs.*;
import java.util.List;
import java.util.Map;

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

    public static void stack(Context ctx) {
        // Get the default VPC
        var vpcId = Ec2Functions.getVpc(GetVpcArgs.builder()
            .default_(true)
            .build())
            .applyValue(vpc -> vpc.id());

        // Create security group
        var securityGroup = new SecurityGroup("web-sg", SecurityGroupArgs.builder()
            .vpcId(vpcId)
            .description("Allow HTTP and SSH")
            .ingress(
                SecurityGroupIngressArgs.builder()
                    .protocol("tcp")
                    .fromPort(80)
                    .toPort(80)
                    .cidrBlocks(List.of("0.0.0.0/0"))
                    .description("Allow HTTP")
                    .build(),
                SecurityGroupIngressArgs.builder()
                    .protocol("tcp")
                    .fromPort(22)
                    .toPort(22)
                    .cidrBlocks(List.of("0.0.0.0/0"))
                    .description("Allow SSH")
                    .build()
            )
            .egress(SecurityGroupEgressArgs.builder()
                .protocol("-1")
                .fromPort(0)
                .toPort(0)
                .cidrBlocks(List.of("0.0.0.0/0"))
                .build())
            .build());

        // Get latest Amazon Linux 2 AMI
        var ami = Ec2Functions.getAmi(GetAmiArgs.builder()
            .mostRecent(true)
            .owners(List.of("amazon"))
            .filters(List.of(GetAmiFilterArgs.builder()
                .name("name")
                .values(List.of("amzn2-ami-hvm-*-x86_64-gp2"))
                .build()))
            .build());

        // Create EC2 instance
        var server = new Instance("web-server", InstanceArgs.builder()
            .instanceType("t2.micro")
            .ami(ami.applyValue(result -> result.id()))
            .vpcSecurityGroupIds(List.of(securityGroup.id()))
            .userData("""
                #!/bin/bash
                yum update -y
                yum install -y httpd
                systemctl start httpd
                systemctl enable httpd
                echo "<h1>Hello from Pulumi</h1>" > /var/www/html/index.html
                """)
            .tags(Map.of("Name", "web-server"))
            .build());

        ctx.export("instanceId", server.id());
        ctx.export("publicIp", server.publicIp());
        ctx.export("publicDns", server.publicDns());
    }
}

Example 3: Lambda Function with API Gateway

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.aws.iam.*;
import com.pulumi.aws.lambda.*;
import com.pulumi.aws.apigatewayv2.*;
import com.pulumi.asset.FileArchive;
import java.util.Map;

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

    public static void stack(Context ctx) {
        // Create IAM role for Lambda
        var role = new Role("lambda-role", RoleArgs.builder()
            .assumeRolePolicy("""
                {
                    "Version": "2012-10-17",
                    "Statement": [{
                        "Action": "sts:AssumeRole",
                        "Principal": {"Service": "lambda.amazonaws.com"},
                        "Effect": "Allow"
                    }]
                }
                """)
            .build());

        // Attach basic execution policy
        new RolePolicyAttachment("lambda-policy", RolePolicyAttachmentArgs.builder()
            .role(role.name())
            .policyArn("arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole")
            .build());

        // Create Lambda function
        var lambda = new Function("hello-lambda", FunctionArgs.builder()
            .runtime("python3.9")
            .role(role.arn())
            .handler("index.handler")
            .code(new FileArchive("./lambda-function"))
            .build());

        // Create HTTP API
        var api = new Api("http-api", ApiArgs.builder()
            .protocolType("HTTP")
            .build());

        // Create Lambda integration
        var integration = new Integration("lambda-integration", IntegrationArgs.builder()
            .apiId(api.id())
            .integrationType("AWS_PROXY")
            .integrationUri(lambda.arn())
            .payloadFormatVersion("2.0")
            .build());

        // Create route
        new Route("route", RouteArgs.builder()
            .apiId(api.id())
            .routeKey("GET /hello")
            .target(integration.id().apply(id -> "integrations/" + id))
            .build());

        // Create stage
        var stage = new Stage("stage", StageArgs.builder()
            .apiId(api.id())
            .name("$default")
            .autoDeploy(true)
            .build());

        // Grant API Gateway permission to invoke Lambda
        new Permission("api-lambda-permission", PermissionArgs.builder()
            .action("lambda:InvokeFunction")
            .function(lambda.name())
            .principal("apigateway.amazonaws.com")
            .sourceArn(api.executionArn().apply(arn -> arn + "/*/*"))
            .build());

        ctx.export("apiEndpoint", api.apiEndpoint());
    }
}

Configuration Management

Pulumi supports configuration values that can be set per stack.

Setting Configuration Values

pulumi config set aws:region us-west-2
pulumi config set myapp:instanceType t2.micro
pulumi config set --secret myapp:dbPassword mySecretPassword

Using Configuration in Code

import com.pulumi.Config;

public static void stack(Context ctx) {
    var config = new Config();

    // Get required value (throws if not set)
    String instanceType = config.require("instanceType");

    // Get optional value with default
    String region = config.get("region").orElse("us-east-1");

    // Get secret value
    String dbPassword = config.requireSecret("dbPassword");

    // Get typed values
    int port = config.requireInt("port");
    boolean enableLogging = config.requireBoolean("enableLogging");
}

Next Steps

Common Patterns - Learn the most frequently used patterns
Web Application Guide - Deploy a complete web application
Data Pipeline Guide - Build data processing pipelines
Security Best Practices - Secure your infrastructure
Service Documentation - Explore AWS services in detail

Additional Resources

Pulumi Documentation
Pulumi AWS Provider
AWS Documentation
Provider Configuration - Detailed provider configuration