# NetworkMode

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

- Source: [`aws-ecs/lib/base/task-definition.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/aws-ecs/lib/base/task-definition.ts#L1042)

## Example

TypeScript:

```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:

```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:

```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();
```

C# / .NET:

```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
    } }
});
```

Golang:

```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

| Member | Description |
| --- | --- |
| `NONE` | The task's containers do not have external connectivity and port mappings can't be specified in the container definition. |
| `BRIDGE` | The task utilizes Docker's built-in virtual network which runs inside each container instance. |
| `AWS_VPC` | The task is allocated an elastic network interface. |
| `HOST` | The task bypasses Docker's built-in virtual network and maps container ports directly to the EC2 instance's network interface directly. |
| `NAT` | The task utilizes Docker's built-in virtual network which runs inside each Windows container instance. |

## Referenced by

- [`CommonTaskDefinitionAttributes`](/v2/docs/aws-cdk-lib.aws_ecs.CommonTaskDefinitionAttributes).networkMode
- [`Ec2TaskDefinitionProps`](/v2/docs/aws-cdk-lib.aws_ecs.Ec2TaskDefinitionProps).networkMode
- [`ExternalTaskDefinitionProps`](/v2/docs/aws-cdk-lib.aws_ecs.ExternalTaskDefinitionProps).networkMode
- [`FargateTaskDefinition`](/v2/docs/aws-cdk-lib.aws_ecs.FargateTaskDefinition).networkMode
- [`ITaskDefinition`](/v2/docs/aws-cdk-lib.aws_ecs.ITaskDefinition).networkMode
- [`PortMap`](/v2/docs/aws-cdk-lib.aws_ecs.PortMap).networkmode
- [`ServiceConnect`](/v2/docs/aws-cdk-lib.aws_ecs.ServiceConnect).networkmode
- [`TaskDefinition`](/v2/docs/aws-cdk-lib.aws_ecs.TaskDefinition).networkMode
- [`TaskDefinitionProps`](/v2/docs/aws-cdk-lib.aws_ecs.TaskDefinitionProps).networkMode
