k8s 中文文档

Bring up a cloud9 IDE and run these prerequisite commands:


  1. ``` sh
  2. # Choose your region, and store it in this environment variable
  3. export AWS_DEFAULT_REGION=ap-southeast-1
  4. echo "export AWS_DEFAULT_REGION=$AWS_DEFAULT_REGION >> ~/.bashrc"

  6. # Install software
  7. sudo yum -y install jq gettext
  8. sudo curl -so /usr/local/bin/ecs-cli https://s3.amazonaws.com/amazon-ecs-cli/ecs-cli-linux-amd64-latest
  9. sudo chmod +x /usr/local/bin/ecs-cli

  11. ```

This installs some handy text parsing utilities, and the latest ecs-cli.

Clone this demo repository:


  1. ``` sh
  2. cd ~/environment
  3. git clone https://github.com/brentley/container-demo.git

  5. ```

Clone our application microservice repositories:


  1. ``` sh
  2. cd ~/environment
  3. git clone https://github.com/brentley/ecsdemo-frontend.git
  4. git clone https://github.com/brentley/ecsdemo-nodejs.git
  5. git clone https://github.com/brentley/ecsdemo-crystal.git

  7. ```

Build a VPC, ECS Cluster, and ALB:


infrastructure

  1. ``` sh
  2. cd ~/environment/container-demo

  4. aws cloudformation deploy --stack-name container-demo --template-file cluster-fargate-private-vpc.yml --capabilities CAPABILITY_IAM
  5. aws cloudformation deploy --stack-name container-demo-alb --template-file alb-external.yml

  7. ```

At a high level, we are building what you see in the diagram. We will have 3 availability zones, each with a public and private subnet. The public subnets will hold service endpoints, and the private subnets will be where our workloads run. Where the image shows an instance, we will have containers on AWS Fargate.

Set environment variables from our build


  1. ``` sh

  3. export clustername=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`ClusterName`].OutputValue' --output text)
  4. export target_group_arn=$(aws cloudformation describe-stack-resources --stack-name container-demo-alb | jq -r '.[][] | select(.ResourceType=="AWS::ElasticLoadBalancingV2::TargetGroup").PhysicalResourceId')
  5. export vpc=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`VpcId`].OutputValue' --output text)
  6. export ecsTaskExecutionRole=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`ECSTaskExecutionRole`].OutputValue' --output text)
  7. export subnet_1=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`PrivateSubnetOne`].OutputValue' --output text)
  8. export subnet_2=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`PrivateSubnetTwo`].OutputValue' --output text)
  9. export subnet_3=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`PrivateSubnetThree`].OutputValue' --output text)
  10. export security_group=$(aws cloudformation describe-stacks --stack-name container-demo --query 'Stacks[0].Outputs[?OutputKey==`ContainerSecurityGroup`].OutputValue' --output text)

  12. cd ~/environment

  14. ```

This creates our infrastructure, and sets several environment variables we will use to automate deploys.

Configure ecs-cli to talk to your cluster:


  1. ``` sh
  2. ecs-cli configure --region $AWS_DEFAULT_REGION --cluster $clustername --default-launch-type FARGATE --config-name container-demo

  4. ```

We set a default region so we can reference the region when we run our commands.

Authorize traffic:


  1. ``` sh
  2. aws ec2 authorize-security-group-ingress --group-id "$security_group" --protocol tcp --port 3000 --cidr 0.0.0.0/0

  4. ```

We know that our containers talk on port 3000, so authorize that traffic on our security group:

Deploy our frontend application:


  1. ``` sh
  2. cd ~/environment/ecsdemo-frontend
  3. envsubst < ecs-params.yml.template >ecs-params.yml

  5. ecs-cli compose --project-name ecsdemo-frontend service up \
  6.     --create-log-groups \
  7.     --target-group-arn $target_group_arn \
  8.     --private-dns-namespace service \
  9.     --enable-service-discovery \
  10.     --container-name ecsdemo-frontend \
  11.     --container-port 3000 \
  12.     --cluster-config container-demo \
  13.     --vpc $vpc

  15. ```

Here, we change directories into our frontend application code directory. The envsubst command templates our ecs-params.yml file with our current values. We then launch our frontend service on our ECS cluster (with a default launchtype of Fargate)

Note: ecs-cli will take care of building our private dns namespace for service discovery, and log group in cloudwatch logs.

View running container:


  1. ``` sh
  2. ecs-cli compose --project-name ecsdemo-frontend service ps \
  3.     --cluster-config container-demo

  5. ```

We should have one task registered.

Check reachability (open url in your browser):


  1. ``` sh
  2. alb_url=$(aws cloudformation describe-stacks --stack-name container-demo-alb --query 'Stacks[0].Outputs[?OutputKey==`ExternalUrl`].OutputValue' --output text)
  3. echo "Open $alb_url in your browser"

  5. ```

This command looks up the URL for our ingress ALB, and outputs it. You should be able to click to open, or copy-paste into your browser.

View logs:


  1. ``` sh
  2. #substitute your task id from the ps command
  3. ecs-cli logs --task-id a06a6642-12c5-4006-b1d1-033994580605 \
  4.     --follow --cluster-config container-demo

  6. ```

To view logs, find the task id from the earlier ps command, and use it in this command. You can follow a task's logs also.

Scale the tasks:


  1. ``` sh
  2. ecs-cli compose --project-name ecsdemo-frontend service scale 3 \
  3.     --cluster-config container-demo
  4. ecs-cli compose --project-name ecsdemo-frontend service ps \
  5.     --cluster-config container-demo

  7. ```

We can see that our containers have now been evenly distributed across all 3 of our availability zones.

Bring up NodeJS backend api:


  1. ``` sh
  2. cd ~/environment/ecsdemo-nodejs
  3. envsubst <ecs-params.yml.template >ecs-params.yml
  4. ecs-cli compose --project-name ecsdemo-nodejs service up \
  5.     --create-log-groups \
  6.     --private-dns-namespace service \
  7.     --enable-service-discovery \
  8.     --cluster-config container-demo \
  9.     --vpc $vpc

  11. ```

Just like earlier, we are now bringing up one of our backend API services. This service is not registered with any ALB, and instead is only reachable by private IP in the VPC, so we will use service discovery to talk to it.

Scale the tasks:


  1. ``` sh
  2. ecs-cli compose --project-name ecsdemo-nodejs service scale 3 \
  3.     --cluster-config container-demo

  5. ```

We can see that our containers have now been evenly distributed across all 3 of our availability zones.

Bring up Crystal backend api:


  1. ``` sh
  2. cd ~/environment/ecsdemo-crystal
  3. envsubst <ecs-params.yml.template >ecs-params.yml
  4. ecs-cli compose --project-name ecsdemo-crystal service up \
  5.     --create-log-groups \
  6.     --private-dns-namespace service \
  7.     --enable-service-discovery \
  8.     --cluster-config container-demo \
  9.     --vpc $vpc

  11. ```

Just like earlier, we are now bringing up one of our backend API services. This service is not registered with any ALB, and instead is only reachable by private IP in the VPC, so we will use service discovery to talk to it.

Scale the tasks:


  1. ``` sh
  2. ecs-cli compose --project-name ecsdemo-crystal service scale 3 \
  3.     --cluster-config container-demo

  5. ```

We can see that our containers have now been evenly distributed across all 3 of our availability zones.

Conclusion:


You should now have 3 services, each running 3 tasks, spread across 3 availability zones. Additionally you should have zero instances to manage. :)

Cleanup:


  1. ``` sh
  2. cd ~/environment/ecsdemo-frontend
  3. ecs-cli compose --project-name ecsdemo-frontend service down --cluster-config container-demo
  4. cd ~/environment/ecsdemo-nodejs
  5. ecs-cli compose --project-name ecsdemo-nodejs service down --cluster-config container-demo
  6. cd ~/environment/ecsdemo-crystal
  7. ecs-cli compose --project-name ecsdemo-crystal service down --cluster-config container-demo

  9. ecs-cli down --force --cluster-config container-demo
  10. aws cloudformation delete-stack --stack-name container-demo-alb
  11. aws cloudformation wait stack-delete-complete --stack-name container-demo-alb
  12. aws cloudformation delete-stack --stack-name container-demo
  13. aws cloudformation delete-stack --stack-name amazon-ecs-cli-setup-private-dns-namespace-$clustername-ecsdemo-frontend

  15. ```