inactive

const cluster = new awsx.ecs.Cluster('mycluster', { vpc });
const myecs = new awsx.ecs.EC2Service('myservice', {
  cluster,
  securityGroups,
  taskDefinitionArgs: {
    containers: {
      flyway: {
        image: 'my/flyway:latest',
        entryPoint: ['/bin/sh'],
        command: ['-c', 'flyway -url=${JDBC_URL} -user=${POSTGRES_USER} -password=${POSTGRES_PASSWORD} migrate'],
        cpu: 1,
        memory: 1024,
        essential: false,
        environment: [
          { 'name': 'POSTGRES_PASSWORD', 'value': dbPassword },
          { 'name': 'JDBC_URL', 'value': jdbcUrl },
          { 'name': 'POSTGRES_USER', 'value': dbUsername },
        ],
      },
      myservice: {
        image: 'my/service:latest',
        cpu: 2,
        memory: 2750,
        environment: [
          { 'name': 'JDBC_PASSWORD', 'value': dbPassword },
          { 'name': 'JDBC_URL', 'value': jdbcUrl },
          { 'name': 'JDBC_USER', 'value': dbUsername },
        ],
        portMappings: [web],
        essential: true,
        dependsOn: [{
          containerName: 'flyway',
          condition: 'SUCCESS'
        }],
      },
    },
  },
});

warning: bucket is deprecated: Use the aws_s3_object resource instead

pulumi_aws.apigateqway.RestApi

pulumi_aws.apigateway

pulumi_aws.apigateway

api.id

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowAssumeRole",
      "Effect": "Allow",
      "Principal": "<http://ec2.amazonaws.com|ec2.amazonaws.com>",
      "Action": "sts:AssumeRole"
    }
  ]
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "<http://ec2.amazonaws.com|ec2.amazonaws.com>"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Principal

Error creating IAM Role xxx-role-53da5df: MalformedPolicyDocument: Syntax error at position (6,41)

ExtraNodeSecurityGroups

command.remote.ConnectionArgs

command.remote.CopyFile

command.remote.Command

@pulumi/awsx

/test/{proxy+}

Unable to create resource at path '/{proxy+}/{proxy+}': Cannot create a child of a resource with a greedy path variable: {proxy+}

{
            path: '/test/{proxy+}',
            apiKeyRequired: false,
            method: 'ANY',
            eventHandler: functions.testFunction,
          },
          {
            path: '/{proxy+}',
            method: 'ANY',
            apiKeyRequired: true,
            target: apiServerTarget,
          },

awsx.apigateway

{proxy+}

{proxy+}

portMappings

awsx.ecs.FargateService

const service = new awsx.ecs.FargateService(n('caddy-service'), {
  cluster,
  taskDefinitionArgs: {
    container: {
      image: caddyImage,
      environment: getCaddyEnvironment(),
      portMappings: targetGroups,
    },
    volumes: [
      {
        name: 'certificates',
        efsVolumeConfiguration: {
          fileSystemId: certificatesEfs.efs.id,
          authorizationConfig: {
            accessPointId: certificatesEfs.ap.id,
            iam: 'ENABLED',
          },
          transitEncryption: 'ENABLED',
        },
      },
    ],
    executionRole: ecsExecutionRole,
    taskRole: createFargateTaskRole('caddy', [certificatesEfs.mountPolicy]),
  },
  waitForSteadyState: false,
});

const httpListener = loadBalancer.createListener(n('http'), {
    vpc,
    port: 80,
    protocol: 'TCP',
    loadBalancer,
    targetGroup: {
      vpc,
      port: 80,
      protocol: 'TCP',
      targetType: 'ip',
      loadBalancer,
    }
  });

  const httpsListener = loadBalancer.createListener(n('https'), {
    vpc,
    port: 443,
    protocol: 'TCP',
    loadBalancer,
    targetGroup: {
      vpc,
      port: 443,
      protocol: 'TCP',
      targetType: 'ip',
      loadBalancer,
    },

portMappings

listener.defaultTargetGroup

"portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                },
                {
                    "containerPort": 443,
                    "hostPort": 443,
                    "protocol": "tcp"
                }
            ],

const pulumi = require("@pulumi/pulumi");
const aws = require("@pulumi/aws");
const awsx = require("@pulumi/awsx");

// Create a public HTTP endpoint (using AWS APIGateway)
const endpoint = new awsx.apigateway.API("hello", {
    routes: [
        // Serve a simple REST API on `GET /name` (using AWS Lambda)
        {
            path: "/source",
            method: "GET",
            eventHandler: (req: any, ctx: any, cb: any) => {
                cb(undefined, {
                    statusCode: 200,
                    body: Buffer.from(JSON.stringify({ name: "AWS" }), "utf8").toString("base64"),
                    isBase64Encoded: true,
                    headers: { "content-type": "application/json" },
                })
            }
        }
    ]
});

// Export the public URL for the HTTP service
exports.url = endpoint.url;

Type                             Name             Status                  Info
     pulumi:pulumi:Stack              store_event-dev  **failed**              1 error; 2 warnings            └─ aws:apigateway:x:API          hello
 ~      ├─ aws:apigateway:RestApi     hello            updated
 +      └─ aws:apigateway:Deployment  hello            **creating failed**     1 error

Diagnostics:
  aws:apigateway:Deployment (hello):
    error: 1 error occurred:
        * Error creating API Gateway Deployment: BadRequestException: The REST API doesn't contain any methods

  pulumi:pulumi:Stack (store_event-dev):
    warning: resource plugin aws is expected to have version >=5.3.0, but has 5.2.0; the wrong version may be on your path, or this may be a bug in the plugin
    warning: resource plugin aws is expected to have version >=5.3.0, but has 5.2.0; the wrong version may be on your path, or this may be a bug in the plugin
    error: update failed

Resources:
    ~ 1 updated
    13 unchanged

Duration: 4s

ApplicationLoadBalancerTargetGroup

loadBalancingAlgorithmType

ApplicationLoadBalancerTargetGroups

const loadBalancer = new awsx.lb.ApplicationLoadBalancer(`${resourcePrefix}ALB`, { securityGroups: [ sg ] }, { replaceOnChanges: ['*'] });

    const targetGroup = loadBalancer.createTargetGroup(
        `${resourcePrefix}Group`, { 
            targetType: "instance", 
            healthCheck: { ... },
            // Would expect loadBalancingAlgorithmType to be set here
            //     but it is not a property of type: ApplicationTargetGroupArgs
        }, { replaceOnChanges: ['*']  });

round_robin