Skip to content
v2.277.0

NetworkMode Enum ​

The networking mode to use for the containers in the task.

Example ​

ts
declare const vpc: ec2.Vpc;

const cluster = new ecs.Cluster(this, 'Cluster', { vpc });

const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {
  vpc,
  description: 'Security group for managed instances',
});

const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(this, 'MICapacityProvider', {
  capacityOptionType: ecs.CapacityOptionType.SPOT,
  subnets: vpc.privateSubnets,
  securityGroups: [securityGroup],
  instanceRequirements: {
    vCpuCountMin: 1,
    memoryMin: Size.gibibytes(2),
  },
});

// Optionally configure security group rules using IConnectable interface
miCapacityProvider.connections.allowFrom(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(80));

// Add the capacity provider to the cluster
cluster.addManagedInstancesCapacityProvider(miCapacityProvider);

const taskDefinition = new ecs.TaskDefinition(this, 'TaskDef', {
  memoryMiB: '512',
  cpu: '256',
  networkMode: ecs.NetworkMode.AWS_VPC,
  compatibility: ecs.Compatibility.MANAGED_INSTANCES,
});

taskDefinition.addContainer('web', {
  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
  memoryReservationMiB: 256,
});

new ecs.FargateService(this, 'FargateService', {
  cluster,
  taskDefinition,
  minHealthyPercent: 100,
  capacityProviderStrategies: [
    {
      capacityProvider: miCapacityProvider.capacityProviderName,
      weight: 1,
    },
  ],
});
python
# vpc: ec2.Vpc


cluster = ecs.Cluster(self, "Cluster", vpc=vpc)

security_group = ec2.SecurityGroup(self, "SecurityGroup",
    vpc=vpc,
    description="Security group for managed instances"
)

mi_capacity_provider = ecs.ManagedInstancesCapacityProvider(self, "MICapacityProvider",
    capacity_option_type=ecs.CapacityOptionType.SPOT,
    subnets=vpc.private_subnets,
    security_groups=[security_group],
    instance_requirements=ec2.InstanceRequirementsConfig(
        v_cpu_count_min=1,
        memory_min=Size.gibibytes(2)
    )
)

# Optionally configure security group rules using IConnectable interface
mi_capacity_provider.connections.allow_from(ec2.Peer.ipv4(vpc.vpc_cidr_block), ec2.Port.tcp(80))

# Add the capacity provider to the cluster
cluster.add_managed_instances_capacity_provider(mi_capacity_provider)

task_definition = ecs.TaskDefinition(self, "TaskDef",
    memory_mi_b="512",
    cpu="256",
    network_mode=ecs.NetworkMode.AWS_VPC,
    compatibility=ecs.Compatibility.MANAGED_INSTANCES
)

task_definition.add_container("web",
    image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
    memory_reservation_mi_b=256
)

ecs.FargateService(self, "FargateService",
    cluster=cluster,
    task_definition=task_definition,
    min_healthy_percent=100,
    capacity_provider_strategies=[ecs.CapacityProviderStrategy(
        capacity_provider=mi_capacity_provider.capacity_provider_name,
        weight=1
    )
    ]
)
java
Vpc vpc;


Cluster cluster = Cluster.Builder.create(this, "Cluster").vpc(vpc).build();

SecurityGroup securityGroup = SecurityGroup.Builder.create(this, "SecurityGroup")
        .vpc(vpc)
        .description("Security group for managed instances")
        .build();

ManagedInstancesCapacityProvider miCapacityProvider = ManagedInstancesCapacityProvider.Builder.create(this, "MICapacityProvider")
        .capacityOptionType(CapacityOptionType.SPOT)
        .subnets(vpc.getPrivateSubnets())
        .securityGroups(List.of(securityGroup))
        .instanceRequirements(InstanceRequirementsConfig.builder()
                .vCpuCountMin(1)
                .memoryMin(Size.gibibytes(2))
                .build())
        .build();

// Optionally configure security group rules using IConnectable interface
miCapacityProvider.connections.allowFrom(Peer.ipv4(vpc.getVpcCidrBlock()), Port.tcp(80));

// Add the capacity provider to the cluster
cluster.addManagedInstancesCapacityProvider(miCapacityProvider);

TaskDefinition taskDefinition = TaskDefinition.Builder.create(this, "TaskDef")
        .memoryMiB("512")
        .cpu("256")
        .networkMode(NetworkMode.AWS_VPC)
        .compatibility(Compatibility.MANAGED_INSTANCES)
        .build();

taskDefinition.addContainer("web", ContainerDefinitionOptions.builder()
        .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
        .memoryReservationMiB(256)
        .build());

FargateService.Builder.create(this, "FargateService")
        .cluster(cluster)
        .taskDefinition(taskDefinition)
        .minHealthyPercent(100)
        .capacityProviderStrategies(List.of(CapacityProviderStrategy.builder()
                .capacityProvider(miCapacityProvider.getCapacityProviderName())
                .weight(1)
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
Vpc vpc;


var cluster = new Cluster(this, "Cluster", new ClusterProps { Vpc = vpc });

var securityGroup = new SecurityGroup(this, "SecurityGroup", new SecurityGroupProps {
    Vpc = vpc,
    Description = "Security group for managed instances"
});

var miCapacityProvider = new ManagedInstancesCapacityProvider(this, "MICapacityProvider", new ManagedInstancesCapacityProviderProps {
    CapacityOptionType = CapacityOptionType.SPOT,
    Subnets = vpc.PrivateSubnets,
    SecurityGroups = new [] { securityGroup },
    InstanceRequirements = new InstanceRequirementsConfig {
        VCpuCountMin = 1,
        MemoryMin = Size.Gibibytes(2)
    }
});

// Optionally configure security group rules using IConnectable interface
miCapacityProvider.Connections.AllowFrom(Peer.Ipv4(vpc.VpcCidrBlock), Port.Tcp(80));

// Add the capacity provider to the cluster
cluster.AddManagedInstancesCapacityProvider(miCapacityProvider);

var taskDefinition = new TaskDefinition(this, "TaskDef", new TaskDefinitionProps {
    MemoryMiB = "512",
    Cpu = "256",
    NetworkMode = NetworkMode.AWS_VPC,
    Compatibility = Compatibility.MANAGED_INSTANCES
});

taskDefinition.AddContainer("web", new ContainerDefinitionOptions {
    Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample"),
    MemoryReservationMiB = 256
});

new FargateService(this, "FargateService", new FargateServiceProps {
    Cluster = cluster,
    TaskDefinition = taskDefinition,
    MinHealthyPercent = 100,
    CapacityProviderStrategies = new [] { new CapacityProviderStrategy {
        CapacityProvider = miCapacityProvider.CapacityProviderName,
        Weight = 1
    } }
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
var vpc Vpc


cluster := ecs.NewCluster(this, jsii.String("Cluster"), &ClusterProps{
	Vpc: Vpc,
})

securityGroup := ec2.NewSecurityGroup(this, jsii.String("SecurityGroup"), &SecurityGroupProps{
	Vpc: Vpc,
	Description: jsii.String("Security group for managed instances"),
})

miCapacityProvider := ecs.NewManagedInstancesCapacityProvider(this, jsii.String("MICapacityProvider"), &ManagedInstancesCapacityProviderProps{
	CapacityOptionType: ecs.CapacityOptionType_SPOT,
	Subnets: vpc.PrivateSubnets,
	SecurityGroups: []ISecurityGroup{
		securityGroup,
	},
	InstanceRequirements: &InstanceRequirementsConfig{
		VCpuCountMin: jsii.Number(1),
		MemoryMin: awscdk.Size_Gibibytes(jsii.Number(2)),
	},
})

// Optionally configure security group rules using IConnectable interface
miCapacityProvider.Connections.AllowFrom(ec2.Peer_Ipv4(vpc.VpcCidrBlock), ec2.Port_Tcp(jsii.Number(80)))

// Add the capacity provider to the cluster
cluster.AddManagedInstancesCapacityProvider(miCapacityProvider)

taskDefinition := ecs.NewTaskDefinition(this, jsii.String("TaskDef"), &TaskDefinitionProps{
	MemoryMiB: jsii.String("512"),
	Cpu: jsii.String("256"),
	NetworkMode: ecs.NetworkMode_AWS_VPC,
	Compatibility: ecs.Compatibility_MANAGED_INSTANCES,
})

taskDefinition.AddContainer(jsii.String("web"), &ContainerDefinitionOptions{
	Image: ecs.ContainerImage_FromRegistry(jsii.String("amazon/amazon-ecs-sample")),
	MemoryReservationMiB: jsii.Number(256),
})

ecs.NewFargateService(this, jsii.String("FargateService"), &FargateServiceProps{
	Cluster: Cluster,
	TaskDefinition: TaskDefinition,
	MinHealthyPercent: jsii.Number(100),
	CapacityProviderStrategies: []CapacityProviderStrategy{
		&CapacityProviderStrategy{
			CapacityProvider: miCapacityProvider.CapacityProviderName,
			Weight: jsii.Number(1),
		},
	},
})

Members ​

MemberDescription
NONEThe task's containers do not have external connectivity and port mappings can't be specified in the container definition.
BRIDGEThe task utilizes Docker's built-in virtual network which runs inside each container instance.
AWS_VPCThe task is allocated an elastic network interface.
HOSTThe task bypasses Docker's built-in virtual network and maps container ports directly to the EC2 instance's network interface directly.
NATThe task utilizes Docker's built-in virtual network which runs inside each Windows container instance.

Referenced by ​