$ cdk init app --language=typescript

new CdkStack(app, 'CdkStack', {
  description: 'API Gatewayを管理するStack',
  env: { region: 'ap-northeast-1' },

  /* For more information, see https://docs.aws.amazon.com/cdk/latest/guide/environments.html */
});

import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import {
  aws_apigateway as apigateway
} from 'aws-cdk-lib';

export class CdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    
    const api = new apigateway.RestApi(this, 'fargate-api');
    
    api.root.addMethod('ANY');

    const books = api.root.addResource('books');
    books.addMethod('GET');
    books.addMethod('POST');
    
    const book = books.addResource('{book_id}');
    const getBookIntegration = new apigateway.HttpIntegration('http://amazon.com');
    book.addMethod('GET', getBookIntegration);
    // book.addMethod('DELETE');
  }
}

import * as elbv2 from '@aws-cdk/aws-elasticloadbalancingv2';

const vpc = new ec2.Vpc(this, 'VPC');
const nlb = new elbv2.NetworkLoadBalancer(this, 'NLB', {
  vpc,
});
const link = new apigateway.VpcLink(this, 'link', {
  targets: [nlb],
});

const integration = new apigateway.Integration({
  type: apigateway.IntegrationType.HTTP_PROXY,
  options: {
    connectionType: apigateway.ConnectionType.VPC_LINK,
    vpcLink: link,
  },
});

 endpointArray.forEach((endpoint) => {
      const resource = text.addResource(endpoint)
      const integration = new apigateway.Integration({
        type: apigateway.IntegrationType.HTTP,
        uri: `https://${nlb.loadBalancerDnsName}/text/${endpoint}`,
        integrationHttpMethod: 'POST',
        options: {
          connectionType: apigateway.ConnectionType.VPC_LINK,
          vpcLink: vpcLink,
          integrationResponses: [{
            statusCode: '200',
            selectionPattern: '2\d{2}',
          }, {
            statusCode: '400',
            selectionPattern: '4\d{2}'
          }],
          passthroughBehavior: apigateway.PassthroughBehavior.NEVER,
        },
      });
      
      resource.addMethod('POST', integration, {
        apiKeyRequired: false,
        methodResponses: [
        {
          // Successful response from the integration
          statusCode: '200',
          responseModels: {
            'application/json': apigateway.Model.EMPTY_MODEL,
          }
        },
        {
          // Same thing for the error responses
          statusCode: '400',
          responseModels: {
            'application/json': apigateway.Model.EMPTY_MODEL,
          },
        }
      ]
      })

ResponseModels: { 'application/json': 'Empty' }

responseModels: {
  'application/json': apigateway.Model.EMPTY_MODEL,
}

     const api = new apigateway.RestApi(this, `${this.stackName}RestApi`, {
        restApiName: 'API',
        deployOptions: {
          stageName: 'development',
          accessLogDestination: new apigateway.LogGroupLogDestination(prdLogGroup),
          accessLogFormat: apigateway.AccessLogFormat.jsonWithStandardFields()
        },
        defaultCorsPreflightOptions: {
          allowOrigins: apigateway.Cors.ALL_ORIGINS
        }
    });

import * as ec2 from 'aws-cdk-lib/aws-ec2';

export class CdkNetworkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // The code that defines your stack goes here
    const vpc = new ec2.Vpc(this, 'VPC', {
      cidr: '10.0.0.0/16'
    });
  }
}

const vpc = new ec2.Vpc(this, 'VPC', {
      cidr: '10.0.0.0/16',
      natGateways: 0,
    });

CdkNetworkStack: creating CloudFormation changeset...
2:03:56 AM | CREATE_FAILED        | AWS::EC2::Subnet                      | VPCIsolatedSubnet2Subnet4B1C8CAA
The CIDR '10.0.192.0/18' conflicts with another subnet (Service: AmazonEC2; Status Code: 400; Error Code: InvalidSubnet.Conflict; Request ID:
5688c2cd-e664-4b5e-9f9d-a04fed7c53e6; Proxy: null)

2:03:56 AM | CREATE_FAILED        | AWS::EC2::Subnet                      | VPCIsolatedSubnet1SubnetEBD00FC6
The CIDR '10.0.128.0/18' conflicts with another subnet (Service: AmazonEC2; Status Code: 400; Error Code: InvalidSubnet.Conflict; Request ID:
36867eca-077b-4aa6-b2ce-5f34f4419abb; Proxy: null)

const vpc = new ec2.Vpc(this, 'TheVPC', {
  // 'cidr' configures the IP range and size of the entire VPC.
  // The IP space will be divided over the configured subnets.
  cidr: '10.0.0.0/21',

  // 'maxAzs' configures the maximum number of availability zones to use
  maxAzs: 3,

  // 'subnetConfiguration' specifies the "subnet groups" to create.
  // Every subnet group will have a subnet for each AZ, so this
  // configuration will create `3 groups × 3 AZs = 9` subnets.
  subnetConfiguration: [
    {
      // 'subnetType' controls Internet access, as described above.
      subnetType: ec2.SubnetType.PUBLIC,

      // 'name' is used to name this particular subnet group. You will have to
      // use the name for subnet selection if you have more than one subnet
      // group of the same type.
      name: 'Ingress',

      // 'cidrMask' specifies the IP addresses in the range of of individual
      // subnets in the group. Each of the subnets in this group will contain
      // `2^(32 address bits - 24 subnet bits) - 2 reserved addresses = 254`
      // usable IP addresses.
      //
      // If 'cidrMask' is left out the available address space is evenly
      // divided across the remaining subnet groups.
      cidrMask: 24,
    },
    {
      cidrMask: 24,
      name: 'Application',
      subnetType: ec2.SubnetType.PRIVATE_WITH_NAT,
    },
    {
      cidrMask: 28,
      name: 'Database',
      subnetType: ec2.SubnetType.PRIVATE_ISOLATED,

      // 'reserved' can be used to reserve IP address space. No resources will
      // be created for this subnet, but the IP range will be kept available for
      // future creation of this subnet, or even for future subdivision.
      reserved: true
    }
  ],
});

    const vpc = ec2.Vpc.fromLookup(this, 'VPC', {
        vpcId: VPCID
    })

Cannot create a VPC Endpoint with no subnets

 const nlb = new elbv2.NetworkLoadBalancer(this, 'LB', {
      vpc,
      internetFacing: false,
      vpcSubnets: {subnets: vpc.publicSubnets}
    });
    
    const listener = nlb.addListener('Listener', {
      port: 80,
    });
    
    listener.addTargets('targetGroup', {
      port: 80,
      protocol: elbv2.Protocol.TCP,
    })

declare const networkLoadBalancer1: elbv2.NetworkLoadBalancer;
declare const networkLoadBalancer2: elbv2.NetworkLoadBalancer;

new ec2.VpcEndpointService(this, 'EndpointService', {
  vpcEndpointServiceLoadBalancers: [networkLoadBalancer1, networkLoadBalancer2],
  acceptanceRequired: true,
  allowedPrincipals: [new iam.ArnPrincipal('arn:aws:iam::123456789012:root')]
});

/**
 * Stack that defines the bucket
 */
class Producer extends cdk.Stack {
  public readonly myBucket: s3.Bucket;

  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'MyBucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
    this.myBucket = bucket;
  }
}

interface ConsumerProps extends cdk.StackProps {
  userBucket: s3.IBucket;
}

/**
 * Stack that consumes the bucket
 */
class Consumer extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props: ConsumerProps) {
    super(scope, id, props);

    const user = new iam.User(this, 'MyUser');
    props.userBucket.grantReadWrite(user);
  }
}

const producer = new Producer(app, 'ProducerStack');
new Consumer(app, 'ConsumerStack', { userBucket: producer.myBucket });

export class InfrastructureStack extends Stack {
  public readonly cluster: ecs.Cluster // public readonlyで定義
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    ...
    this.cluster = new ecs.Cluster(this, 'Cluster', {
      vpc: vpc,
    });

const infra = new InfrastructureStack(app, 'InfrastructureStack', {
  env: { region: 'ap-northeast-1' },
})

new BackendStack(app, 'BackendStack', {
  env: { region: 'ap-northeast-1' },
  cluster: infra.cluster,   // InfrastructureStackで定義したリソースをpropsとして渡す
});

interface backendStackProps extends StackProps {
  cluster: ecs.Cluster
}


export class BackendStack extends Stack {
  constructor(scope: Construct, id: string, props: backendStackProps) {
    super(scope, id, props);
    ...
    const backendService = new ecs.FargateService(this, 'BackendService', {
      cluster: props.cluster, // propsとして渡されたclusterを使う
      ...

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

# Digestで指定
   ecs.ContainerImage.fromEcrRepository(
      props.repository,
      "sha256:8b49246788dc37dede413a5f90e3f33a450ab4df9fb8fb89f415a1b7d0a53008"
    );

# タグで指定
new ecs.EcrImage(props.repository, 'nginx-latest'),

CannotPullContainerError: ref pull has been retried 5 time(s): failed to copy: httpReadSeeker: failed open: failed to do request: Get https://prod-ap-northeast-1-starport-layer-bucket.s3.ap-northeast-1.amazonaws.com/4

ResourceInitializationError: failed to validate logger args: : signal: killed

ResourceInitializationError: unable to pull secrets or registry auth: pull command failed: : signal: killed

# digest=$(docker images --no-trunc -q $imageName) # これはローカルのimageのdigestなので間違い
digest=$(docker inspect $imageName:latest --format='{{index .RepoDigests 0}}' | sed -e 's/.*\@\(.*\)/\1/')
yarn cdk deploy '*' -c stage=$stage -c digest=$digest --require-approval=never

const repository = new ecr.Repository(this, 'Repository');

$ aws ecr get-login --no-include-email
$ docker-compose push
ERROR: no basic auth credentials

cdk synth --quiet

Resolution error: Resolution error: Cannot use resource 'RepositoryStack/BackendRepository' in a cross-environment fashion, the resource's physical name must be explicit set or use `PhysicalName.GENERATE_IF_NEEDED`.

const arn = 'arn:aws:...';
    const certificate = cert.Certificate.fromCertificateArn(this, 'Certificate', arn);

Error: HostedZone.fromHostedZoneId doesn't support "zoneName"

    const zone = route53.HostedZone.fromHostedZoneAttributes(this, 'MyZone', {
      zoneName: HOSTZONE_NAME,
      hostedZoneId: HOSTZONE_ID,
    });
    new route53.ARecord(this, 'ARecord', {
      zone: zone,
      recordName: SUBDOMAIN_NAME + '.' + HOSTZONE_NAME,
      target: route53.RecordTarget.fromAlias(new targets.LoadBalancerTarget(this.nlb)),
    });

import { Stack, StackProps, CfnOutput } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as ecr from 'aws-cdk-lib/aws-ecr';

export class RepositoryStack extends Stack {
  // 共有するリソースについてpublicで定義を行う
  public readonly repository: ecr.Repository

  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    
    // ECRのレポジトリ作成
    this.repository = new ecr.Repository(this, 'BackendRepository');
    
    // 後続で利用するためOutputを設定
    new CfnOutput(this, 'ecrUri', {
      value: this.repository.repositoryUri,
      description: 'The Uri for ECR Repository'
    });
  }
}

cdk deploy RepositoryStack --outputs-file ./cdk-outputs.json

      throw new Error('Cannot create a VPC Endpoint with no subnets');
            ^
Error: Cannot create a VPC Endpoint with no subnets

import * as cfn from 'aws-cdk-lib/cloudformation-include';

// CloudFormationテンプレートを読み込んでリソースを作成する
    const cfnTemplate = new cfn.CfnInclude(this, 'Template', {
        templateFile: 'lib/cfn/template.yml',
        parameters: {
          'VPCID': vpcId,
      },
    });

 const cfnVpcEndpoint = cfnTemplate.getResource('ResourceName') as ec2.CfnVPCEndpoint;
cfnVpcEndpoint.subnetIds = subnetIds;

1:38:53 AM | CREATE_FAILED        | AWS::EC2::VPCEndpoint | EcrApiVpcEndpoint
Resource handler returned message: "private-dns-enabled cannot be set because there is already a conflicting DNS domain for api.ecr.
ap-northeast-1.amazonaws.com

{
    region: process.env.CDK_DEFAULT_REGION,
    account: process.env.CDK_DEFAULT_ACCOUNT,
}

    console.log('accountId: ', cdk.Stack.of(this).account);
    console.log('region: ', cdk.Stack.of(this).region);

sudo gitlab-runner register \
  --non-interactive \
  --url "https://gitlab.com/" \
  --registration-token "o8GVtFJZmsAEa6JyApN_" \
  --executor "docker" \
  --docker-image alpine:latest \
  --docker-privileged \
  --description "docker-runner" \