Create AWS CodeDeploy Applications

The aws:codedeploy/application:Application resource, part of the Pulumi AWS provider, defines a CodeDeploy application container that groups deployment configurations and deployment groups for a specific compute platform. This guide focuses on one capability: compute platform selection.

CodeDeploy applications are organizational containers, not deployment executors. They group deployment groups and configurations but don’t deploy code themselves. The examples are intentionally small. Combine them with DeploymentGroup and DeploymentConfig resources for complete deployment pipelines.

Create an application for EC2 or on-premises deployments

Most CodeDeploy usage starts with the Server platform for traditional EC2 or on-premises deployments.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.codedeploy.Application("example", {
    computePlatform: "Server",
    name: "example",
});

import pulumi
import pulumi_aws as aws

example = aws.codedeploy.Application("example",
    compute_platform="Server",
    name="example")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/codedeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codedeploy.NewApplication(ctx, "example", &codedeploy.ApplicationArgs{
			ComputePlatform: pulumi.String("Server"),
			Name:            pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.CodeDeploy.Application("example", new()
    {
        ComputePlatform = "Server",
        Name = "example",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.codedeploy.Application;
import com.pulumi.aws.codedeploy.ApplicationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new Application("example", ApplicationArgs.builder()
            .computePlatform("Server")
            .name("example")
            .build());

    }
}

resources:
  example:
    type: aws:codedeploy:Application
    properties:
      computePlatform: Server
      name: example

The computePlatform property determines what type of infrastructure this application can deploy to. Server is the default and supports EC2 instances and on-premises servers. The name property provides a unique identifier within your AWS account.

Create an application for Lambda function deployments

Serverless teams use the Lambda platform to manage traffic shifting between function versions.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.codedeploy.Application("example", {
    computePlatform: "Lambda",
    name: "example",
});

import pulumi
import pulumi_aws as aws

example = aws.codedeploy.Application("example",
    compute_platform="Lambda",
    name="example")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/codedeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codedeploy.NewApplication(ctx, "example", &codedeploy.ApplicationArgs{
			ComputePlatform: pulumi.String("Lambda"),
			Name:            pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.CodeDeploy.Application("example", new()
    {
        ComputePlatform = "Lambda",
        Name = "example",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.codedeploy.Application;
import com.pulumi.aws.codedeploy.ApplicationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new Application("example", ApplicationArgs.builder()
            .computePlatform("Lambda")
            .name("example")
            .build());

    }
}

resources:
  example:
    type: aws:codedeploy:Application
    properties:
      computePlatform: Lambda
      name: example

Setting computePlatform to Lambda restricts this application to Lambda function deployments. CodeDeploy handles gradual traffic shifting and automatic rollback for Lambda aliases.

Create an application for ECS service deployments

Container deployments use the ECS platform for blue/green deployments behind load balancers.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.codedeploy.Application("example", {
    computePlatform: "ECS",
    name: "example",
});

import pulumi
import pulumi_aws as aws

example = aws.codedeploy.Application("example",
    compute_platform="ECS",
    name="example")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/codedeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := codedeploy.NewApplication(ctx, "example", &codedeploy.ApplicationArgs{
			ComputePlatform: pulumi.String("ECS"),
			Name:            pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.CodeDeploy.Application("example", new()
    {
        ComputePlatform = "ECS",
        Name = "example",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.codedeploy.Application;
import com.pulumi.aws.codedeploy.ApplicationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new Application("example", ApplicationArgs.builder()
            .computePlatform("ECS")
            .name("example")
            .build());

    }
}

resources:
  example:
    type: aws:codedeploy:Application
    properties:
      computePlatform: ECS
      name: example

The ECS platform enables blue/green deployments where CodeDeploy creates new task sets and shifts traffic between them. This requires ECS services configured with load balancers.

Beyond these examples

These snippets focus on compute platform selection (Server, Lambda, ECS). They’re intentionally minimal rather than complete deployment pipelines.

The examples don’t rely on pre-existing infrastructure. They focus on creating the application container that will later hold deployment groups and configurations.

To keep things focused, application-level properties are omitted, including:

  • Resource tagging (tags property)
  • Explicit region configuration (region property)
  • GitHub integration (linkedToGithub, githubAccountName)

These omissions are intentional: the goal is to illustrate how each compute platform is configured, not provide drop-in deployment modules. See the CodeDeploy Application resource reference for all available configuration options.

Let's create AWS CodeDeploy Applications

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Platform Configuration
What compute platforms does CodeDeploy support?
CodeDeploy supports three compute platforms: ECS, Lambda, and Server. The default platform is Server if not specified.
Can I change the compute platform after creating the application?
No, the computePlatform property is immutable. Changing it after creation will force the application to be recreated.
Resource Management
How do I import an existing CodeDeploy application?
Import using the application name: pulumi import aws:codedeploy/application:Application example my-application

Using a different cloud?

Explore integration guides for other cloud providers:

Azure Guides GCP Guides