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 two capabilities: compute platform selection and application naming.

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

Create an application for EC2 or on-premises deployments

Most CodeDeploy usage starts with the Server platform for deploying to EC2 instances or on-premises servers.

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 which deployment targets the application supports. Server is the default and handles traditional application deployments to EC2 instances or on-premises servers. The name property provides a unique identifier for organizing deployment groups and configurations.

Create an application for Lambda function deployments

Serverless deployments use CodeDeploy to manage traffic shifting between Lambda 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 enables traffic shifting strategies for Lambda function deployments. CodeDeploy gradually shifts traffic between function versions, monitoring CloudWatch alarms for automatic rollback.

Create an application for ECS service deployments

Container-based deployments use CodeDeploy to orchestrate blue/green deployments for ECS services.

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 compute platform enables blue/green deployments that swap task sets behind load balancers. CodeDeploy creates a replacement task set, shifts traffic gradually, and terminates the original task set after validation.

Beyond these examples

These snippets focus on specific application-level features: compute platform selection and application naming. They’re intentionally minimal rather than complete deployment pipelines.

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

To keep things focused, common application patterns are omitted, including:

Resource tagging (tags)
Explicit region configuration (region)
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

Configuration & Setup

Can I change the compute platform after creating the application?

No, computePlatform is immutable and cannot be changed after creation. To switch platforms, you must recreate the application.

What compute platforms are available for CodeDeploy applications?

CodeDeploy supports three compute platforms: ECS, Lambda, and Server. The default is Server if not specified.

GitHub Integration

How do I connect my CodeDeploy application to GitHub?

The githubAccountName and linkedToGithub fields are output-only properties that reflect connection status. GitHub integration is configured outside the application resource itself.

Using a different cloud?

Explore integration guides for other cloud providers:

Azure Guides GCP Guides