昨天教大家怎麼簡單的在 LINE Notify 上面看到 CloudWatch 的 Alarm，不過這樣只有通知沒有目前的狀態圖對於平常判斷系統是否有問題好像少了什麼，所以今天來教大家怎麼讓 LINE Notify 上面除了可以看到 CloudWatch 的 Alarm 之外還可以看到 CloudWatch Graph

而今天的內容除了可以把訊息發到 LINE Notify 之外還加碼支援把訊息發送到 Discord

今日目標

1. 更新 Lambda 程式
2. Lambda 加入 Policy
3. Lambda 加入 environment
4. 加入壓測工具

創建一個 CloudWatch Alarm 的含圖告警

更新 Lambda 程式

先更新新版的 Lambda 程式，程式位置 GitHub

主要功能我都已經先寫好並且放到 GitHub 上面了，所以大家只要 pull 就可以取得新版程式了呦！

寫得很爛請大家見諒

$ cd lambda
$ git pull

Lambda 加入 Policy

我們需要讓 Lambda 可以吃到 CloudWatch 的資料，所以要修改一下它的權限，其實這邊權限還可以再給得更小不過今天就先開個 cloudwatch:Get* 吧 XD

myFunction.addToRolePolicy(
  new iam.PolicyStatement({
    actions: ["cloudwatch:Get*"],
    resources: ["*"],
  })
);

Lambda 加入 environment

還記得昨天的範例我們需要直接修改 "your-line-notify-token" 嗎？這個部分我做了一點改變，讓參數直接從 CDK 喂給 Lambda 的 environment

const myFunction = new lambda.Function(this, "Lambda", {
  handler: "index.handler",
  runtime: lambda.Runtime.NODEJS_10_X,
  code: lambda.Code.fromAsset("lambda"),
  environment: {
    LINE_NOTIFY_TOKEN: "your-line-notify-token",
    DISCORD_URL: "your-discord-webhook-url",
  },
});

取得 Discord Webhook 的方法可以參考官方文件

加入壓測工具

昨天的教學因為篇幅關係沒有介紹到如何使用人為方法給予機器負載做測試，今天來把這段補起來

我們平常使用的 AMI 為 AMAZON LINUX 2 所以以此介紹，首先我們需要先安裝 epel 不然我們沒有軟體包可以使用

$ sudo amazon-linux-extras install epel -y

如果對 epel 有問題可以參考 AWS 的文件 How do I enable the EPEL repository for my Amazon EC2 instance running CentOS, RHEL, or Amazon Linux?

安裝 stress-ng

這次我們選用 stress-ng 作為我們的測試工具，還是記得我們前面有教大家使用 User Data 嗎？我們就直接請 User Data 安裝這樣我們開啟系統的時候就可以直接使用了

$ sudo yum install stress-ng -y

製造 CPU Load

我們範例定義的 CPU Utilization threshold 為 5 基本上只要給他一點壓力 CloudWatch Alarm 就會有反應了，所以我們先給予他 CPU 40% 的壓力作為測試給予壓力的指令如：

$ stress-ng -c 1 -l 40
stress-ng: info:  [1084] defaulting to a 86400 second run per stressor
stress-ng: info:  [1084] dispatching hogs: 1 cpu
stress-ng: info:  [1084] successful run completed in 74.43s (1 min, 14.43 secs)

整理一下範例

今天的範例建立了

• EC2
  • 放入 Default VPC 加速部署
  • 等級 t3a.nano
  • Security Group 22 全開
  • Image：AMAZON_LINUX_2
  • Subnet：PUBLIC
  • User Data：
    • amazon-linux-extras install epel -y
    • yum install stress-ng tmux htop -y
• SNS
• CloudWatch
• Lambda

const vpc = ec2.Vpc.fromLookup(this, "VPC", {
  isDefault: true,
});

const securityGroup = new ec2.SecurityGroup(this, "SecurityGroup", {
  vpc,
  allowAllOutbound: true,
});
securityGroup.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.tcp(22));

const instance = new ec2.Instance(this, "Instance", {
  vpc,
  instanceType: ec2.InstanceType.of(
    ec2.InstanceClass.T3A,
    ec2.InstanceSize.NANO
  ),
  machineImage: ec2.MachineImage.latestAmazonLinux({
    generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,
  }),
  securityGroup,
  vpcSubnets: {
    subnetType: ec2.SubnetType.PUBLIC,
  },
  keyName: "KeyPair",
});
instance.userData.addCommands(
  `amazon-linux-extras install epel -y`,
  `yum install stress-ng tmux htop -y`
);
new cdk.CfnOutput(this, "instance", {
  value: instance.instancePublicDnsName,
});

const topic = new sns.Topic(this, "Topic");

const metric = new cloudwatch.Metric({
  namespace: "AWS/EC2",
  metricName: "CPUUtilization",
  dimensions: {
    InstanceId: instance.instanceId,
  },
  period: cdk.Duration.minutes(1),
});

const alarm = new cloudwatch.Alarm(this, "Alarm", {
  metric,
  threshold: 5,
  evaluationPeriods: 1,
});

alarm.addAlarmAction(new cw_actions.SnsAction(topic));

const myFunction = new lambda.Function(this, "Lambda", {
  handler: "index.handler",
  runtime: lambda.Runtime.NODEJS_10_X,
  code: lambda.Code.fromAsset("lambda"),
  environment: {
    LINE_NOTIFY_TOKEN: "your-line-notify-token",
    DISCORD_URL: "your-discord-webhook-url",
  },
});
myFunction.addToRolePolicy(
  new iam.PolicyStatement({
    actions: ["cloudwatch:Get*"],
    resources: ["*"],
  })
);

topic.addSubscription(new subscriptions.LambdaSubscription(myFunction));

參考資料

• https://github.com/aws-samples/aws-cloudwatch-snapshot-graphs-alert-context

今天介紹如何部署一個 CloudWatch Alarm 的含圖告警，有機會我會在修改目前的程式讓它變得更靈活使用或是支援更多的通訊程式，希望對大家有幫助 ~

前幾天說了很多建置系統的方法但是對於監控系統沒有太多的說明，今天就來一個 CloudWatch 傳送 Alarm 到 LINE 的教學吧！先給大家看看今天的成品

目標

今天的目標是要模擬我們開的 EC2 發生 CPU Utilization 過高觸發 CloudWatch Alarm 發送告警訊息給 LINE Notify 整個觸發流程是

1. EC2 CPU Utilization 過高觸發 CloudWatch Alarm
2. CloudWatch Alarm 觸發 SNS Action
3. SNS Action 觸發 Lambda
4. Lambda 發送 HTTP Request 把訊息帶給 LINE Notify

所以需要創建的服務會有

1. EC2
2. CloudWatch Alarm
3. SNS Action
4. Lambda

創建 SNS Topic

我們先創建 SNS

const topic = new sns.Topic(this, "Topic");

創建 Cloudwatch Metric

在創建 Cloudwatch Alarm 之前需要先把資料抓出來，所以先創建一個 Metric，指定我們要抓的資料是 AWS/EC2 以 CPU Utilization 為目標，並且指定 EC2 Instance Id

const metric = new cloudwatch.Metric({
  namespace: "AWS/EC2",
  metricName: "CPUUtilization",
  dimensions: {
    InstanceId: instance.instanceId,
  },
  period: cdk.Duration.minutes(1),
});

創建 Cloudwatch Alarm

準備好 Metric 後就可以把 Alarm 創建起來，範例定義 threshold 為 5

平常比較常用的應該是 85 上下取一個比較能判斷發生問題的值，不過我們為了方便測試以 5 為我們的閾並設定 period 為 1

const alarm = new cloudwatch.Alarm(this, "Alarm", {
  metric,
  threshold: 5,
  evaluationPeriods: 1,
});

串接 Cloudwatch Alarm 與 SNS

設定完之後把 Alarm 與 SNS 連起來

import * as cw_actions from "@aws-cdk/aws-cloudwatch-actions";

alarm.addAlarmAction(new cw_actions.SnsAction(topic));

創建 Lambda 並取得發送 LINE Notify 方法

創建一個 Lambda 這邊我準備好了腳本大家只要把它 Clone 下來就好拉！

Github：https://github.com/clarencetw/sns-alarm.git

$ git clone https://github.com/clarencetw/sns-alarm.git lambda

這邊記得要切換 tag 到 v1.0.0 ，不然會與此篇範例教學不一樣呦！

$ git checkout v1.0.0

還有一個要注意的是要修改 "your-line-notify-token"，此參數是 LINE Notify 專用的 Token 取得方法請參考我之前的文章

• LINE NOTIFY 運用
• [LINE BOT 好好玩 30 天玩轉 LINE API] 第 19 天：為什麼發訊息都要錢，有不用錢的嗎？

const myFunction = new lambda.Function(this, "Lambda", {
  handler: "index.handler",
  runtime: lambda.Runtime.NODEJS_10_X,
  code: lambda.Code.fromAsset("lambda"),
});

SNS 訂閱 Lambda

topic 訂閱剛剛創建的 Lambda

topic.addSubscription(new subscriptions.LambdaSubscription(myFunction));

在 SNS 的 Subscriptions 可以看到 Endpoint 為 Lambda

可以在 CloudWatch 看到 SNS 的 Trigger

整理一下

如此就完成一個可以收到 CloudWatch 通知的系統拉！

這邊也跟大家說明一下之前的範例都是每次建立一個 VPC 這樣其實有點久，所以這次就使用 fromLookup 讓它尋找 Default VPC 可以讓整個建置的速度變快

const vpc = ec2.Vpc.fromLookup(this, "VPC", {
  isDefault: true,
});

const securityGroup = new ec2.SecurityGroup(this, "SecurityGroup", {
  vpc,
  allowAllOutbound: true,
});
securityGroup.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.tcp(22));

const instance = new ec2.Instance(this, "Instance", {
  vpc,
  instanceType: ec2.InstanceType.of(
    ec2.InstanceClass.T3A,
    ec2.InstanceSize.NANO
  ),
  machineImage: ec2.MachineImage.latestAmazonLinux({
    generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,
  }),
  securityGroup,
  vpcSubnets: {
    subnetType: ec2.SubnetType.PUBLIC,
  },
  keyName: "KeyPair",
});

const topic = new sns.Topic(this, "Topic");

const metric = new cloudwatch.Metric({
  namespace: "AWS/EC2",
  metricName: "CPUUtilization",
  dimensions: {
    InstanceId: instance.instanceId,
  },
  period: cdk.Duration.minutes(1),
});

const alarm = new cloudwatch.Alarm(this, "Alarm", {
  metric,
  threshold: 5,
  evaluationPeriods: 1,
});

alarm.addAlarmAction(new cw_actions.SnsAction(topic));

const myFunction = new lambda.Function(this, "Lambda", {
  handler: "index.handler",
  runtime: lambda.Runtime.NODEJS_10_X,
  code: lambda.Code.fromAsset("lambda"),
});

topic.addSubscription(new subscriptions.LambdaSubscription(myFunction));

今天介紹了一個使用 CloudWatch 發送 LINE Notify 的方法，其實網路上應該有滿多文章在教學這段的，不過這次的重點其實在於教大家怎麼使用 CDK 串接 CloudWatch、SNS 與 Lambda！希望對大家有幫助 ~

昨天介紹完了 Cluster 今天來介紹如何使用 CDK 建立 EKS Service 往常我們如果使用 kubectl 要新增服務或是控制都會需要用到 yaml 檔案，但今天我們使用 CDK 部署 EKS 不用使用到 yaml，那我們要怎麼控制 Kubernetes（K8S）呢？ 我們用 typescript 寫 CDK 當然就是直接寫 JSON 拉！是不是很神奇呢？快點跟著我看下去吧！

部署目標

在部署前我們先整理一下這次目標需要什麼

1. 部署一個服務名稱：hello-kubernetes
2. replicas 設定為：3
3. Docker Image 使用：paulbouwer/hello-kubernetes:1.5
4. Container 內部 port 為：8080
5. 設定一個 LoadBalancer 外部 port 為 80 對接內部的 hello-kubernetes 服務

部署 EKS Service

定義 Deployment

整理好後我們先設定 Deployment 以部署 Kubernetes（K8S）的 YAML 來說，我們要處理 Container 名稱、數量、內部 Port

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes
spec:
  replicas: 3
  selector:
    matchLabels: hello-kubernetes
  template:
    metadata:
      labels: hello-kubernetes
    spec:
      containers:
        - name: hello-kubernetes
          image: 'paulbouwer/hello-kubernetes:1.5'
          ports:
            - containerPort: 8080

但我們說過我們這次的部署不需要 YAML 所以我們直接使用 TypeScript 來寫

const appLabel = { app: "hello-kubernetes" };

const deployment = {
  apiVersion: "apps/v1",
  kind: "Deployment",
  metadata: { name: "hello-kubernetes" },
  spec: {
    replicas: 3,
    selector: { matchLabels: appLabel },
    template: {
      metadata: { labels: appLabel },
      spec: {
        containers: [
          {
            name: "hello-kubernetes",
            image: "paulbouwer/hello-kubernetes:1.5",
            ports: [{ containerPort: 8080 }],
          },
        ],
      },
    },
  },
};

Deployment 部署方法可以參考 kubernetes Documentation

定義 Service

而在部署 Kubernetes（K8S）的 Service YAML，需要處理 LoadBalancer 外部 port 與內部 Service 的對應

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 8080
  selector: hello-kubernetes

想好後轉換成 TypeScript 的程式

const service = {
  apiVersion: "v1",
  kind: "Service",
  metadata: { name: "hello-kubernetes" },
  spec: {
    type: "LoadBalancer",
    ports: [{ port: 80, targetPort: 8080 }],
    selector: appLabel,
  },
};

Service 部署方法可以參考 kubernetes Documentation

設定 Manifest

往常使用 Kubernetes（K8S）我們需要使用 kubectl apply -f hello-kubernetes.yaml 而在 CDK 我們可以直接使用 addManifest 塞入 cluster 就做完了！

cluster.addManifest("mypod", service, deployment);

顯示 Load Balancer

在使用 Kubernetes（K8S 需要使用 kubectl get rc,services 取得我們 Service 的位置，那使用 CDK 可以直接讓它在部署的時候用 Output 直接吐出來！從此可以不用再使用 kubectl 拉！ヽ(✿ﾟ▽ﾟ)ノ

new cdk.CfnOutput(this, "LoadBalancer", {
  value: cluster.getServiceLoadBalancerAddress("hello-kubernetes"),
});

測試

說了這麼多我們來部署測試看看吧！雖然上面說我們不需要用到 kubectl 不過我們還是需要用它來進行測試確定系統有沒有如所想的部署執行一下 cdk deploy 等它 15 ~ 30 分鐘吧！ ( • ̀ω•́ )

執行完後的 Output：

Outputs:
CdkEksStack.LoadBalancer = aba304eea204b4239abb905439ac8ec7-1947016485.us-west-2.elb.amazonaws.com
CdkEksStack.eksConfigCommandDB09280A = aws eks update-kubeconfig --name eksB49B8EA3-7fcd6a64ed934f00ae43ec1cb67a87fa --region us-west-2 --role-arn arn:aws:iam::869989823608:role/CdkEksStack-mastersRole634808EE-1I504Q4EPLS70
CdkEksStack.eksGetTokenCommand8952195F = aws eks get-token --cluster-name eksB49B8EA3-7fcd6a64ed934f00ae43ec1cb67a87fa --region us-west-2 --role-arn arn:aws:iam::869989823608:role/CdkEksStack-mastersRole634808EE-1I504Q4EPLS70

AWS Console 的 Load balancer

可以看到在 AWS Load balancer 建立了一個 classic 的服務而他的 DNS 如上面的 CDK Output

而在 Instances 可以看到我們的 Cluster 機器確實註冊在這個 Load balancer 後面

Tags 可以看到有些設定被定義

查看 Kubernetes replicas 數量

可以使用 kubectl get pods 看到我們的 replicas 確實有設定為 3

$ kubectl get pods
NAME                                READY   STATUS    RESTARTS   AGE
hello-kubernetes-5655b546f8-cm66l   1/1     Running   0          49m
hello-kubernetes-5655b546f8-l8xkj   1/1     Running   0          49m
hello-kubernetes-5655b546f8-msjh6   1/1     Running   0          49m
mypod                               1/1     Running   0          97m

查看 Kubernetes Services 的部署狀態

使用 kubectl get rc,services 查看我們的 Load Balancer 確實也與 AWS Console 顯示的一樣

$ kubectl get rc,services
NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP                                                               PORT(S)        AGE
service/hello-kubernetes   LoadBalancer   172.20.200.52   aba304eea204b4239abb905439ac8ec7-1947016485.us-west-2.elb.amazonaws.com   80:30139/TCP   35m
service/kubernetes         ClusterIP      172.20.0.1      <none>                                                                    443/TCP        3h35m

瀏覽一下 Kubernetes 部署的網頁

瀏覽一下剛剛部署的 LoadBalancer 可以看到我們的 pod id 每次都不一樣，如剛剛部署的 replicas 數量會有三個輪流吃到我們的 request

查看 pod log

雖然我們這邊主要不是介紹 Kubernetes 不過順便提一下如果想要看到 pod 的 log 可以使用 kubectl logs 帶上 id 查看 Log

$ kubectl logs hello-kubernetes-5655b546f8-cm66l
npm info it worked if it ends with ok
npm info using [email protected]
npm info using [email protected]
npm info lifecycle [email protected]~prestart: [email protected]
npm info lifecycle [email protected]~start: [email protected]

> [email protected] start /usr/src/app
> node server.js

Listening on: http://hello-kubernetes-5655b546f8-cm66l:8080
::ffff:10.0.255.11 - - [09/Oct/2020:11:17:29 +0000] "GET / HTTP/1.1" 200 667 "-" "curl/7.64.1"
::ffff:10.0.255.11 - - [09/Oct/2020:11:17:40 +0000] "GET /favicon.ico HTTP/1.1" 404 150 "http://aba304eea204b4239abb905439ac8ec7-1947016485.us-west-2.elb.amazonaws.com/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.121 Safari/537.36"

今天介紹 CDK 可以神奇的處理很多原本要用 kubectl 才可以處理的事情是不是超神奇的啊！！！

最近談了這麼多的 ECS 來換換口味來個 Amazon Elastic Kubernetes Service 吧！通常我們簡稱它為 Amazon EKS 或是 AWS EKS 後面我們會直接使用 AWS EKS 稱呼它

AWS EKS

發布時間

在一開始我們先來簡單介紹一下 AWS EKS 這個服務，它在 2017/11/29 發布預覽版，還記得那個時候剛發布就去申請了 preview，初期版本滿簡單的而且不能外掛任何的模組

Amazon Elastic Container Service for Kubernetes 簡介 (預覽)

經過了半年多在 2018/06/05 發布了正式版

Amazon Elastic Container Service for Kubernetes 現在普遍可用

在一年後 2019/06/03 開始支援 AWS Fargate

使用 Amazon EKS 和 AWS Fargate 執行無伺服器 Kubernetes Pod

在 2020/03/10 也開始更新到 1.15 版

Amazon EKS 現在支援Kubernetes 1.15 版 – AWS

而在 2020/04/30 更新到 Kubernetes 1.16 版

Amazon EKS 現在支援 Kubernetes 1.16 版

價格

在 2020/01/21 之前的價格是每小時 0.20 USD 發布訊息後由原本的 0.20 USD 降至每小時 0.10 USD 價格降低了 50%，其實這個價格說貴不貴說便宜也不便宜因為自己起一台 AWS c5.large 也需要 0.10 USD 而且還需要自己顧這台 EC2

Amazon EKS 宣佈價格降低 50%

使用 CDK 建立 AWS EKS

簡單介紹了 AWS EKS 的歷史那我們就來使用 AWS CDK 建立 AWS EKS 吧！

AWS EKS 架構

在說明之前我們先來看一下我們今天要完成的目標架構圖，今天要完成的地方是紅色框框裡面的部分，有 Amazon EKS 本身跟 Kubernetes Cluster 讓它跑在 EC2 上面

出處 AWS re:Invent 2019: [REPEAT 1] Amazon EKS under the hood (CON421-R1) PPT YouTube

CDK 程式

其實要使用 CDK 建立一個 EKS 非常的簡單只要一行就可以把整個非常龐大的 K8S 啟動

const cluster = new eks.Cluster(this, "eks", {
  version: eks.KubernetesVersion.V1_17,
});

如此配置會在後面創建一個新的 VPC 與兩台 m5.large 的機器

https://docs.aws.amazon.com/cdk/api/latest/docs/aws-eks-readme.html#managed-node-groups

https://docs.aws.amazon.com/cdk/api/latest/docs/aws-eks-readme.html#masters-role

EKS 建立 master role

如此配置 EKS 沒有辦法訪問，所以我們建立一個 Role 它會把 IAM 與 system:masters 進行一個綁定，來修改一下程式

const mastersRole = new iam.Role(this, "mastersRole", {
  assumedBy: new iam.AccountRootPrincipal(),
});

const cluster = new eks.Cluster(this, "eks", {
  version: eks.KubernetesVersion.V1_17,
  mastersRole,
});

修改 spot cluster

我在測試比較喜歡用 spot 的機器畢竟 spot 的機器比較便宜，所以我在這邊先做一些修改加入 spot 的設定，如果之前有看我的 ECS 介紹就會覺得這邊很熟悉我們只要跟 auto scaling group 說明 spot 的 price 就會幫我們啟動一個 spot 的 cluster 了！

這邊要注意原本的 cluster 也會啟動機器所以要把 defaultCapacity 設定為 0 不然會跑出三台呦！

const cluster = new eks.Cluster(this, "eks", {
  version: eks.KubernetesVersion.V1_17,
  defaultCapacity: 0,
  mastersRole,
});
    
cluster.addAutoScalingGroupCapacity("spot", {
  spotPrice: "0.1094",
  instanceType: new ec2.InstanceType("t3.large"),
});

部署測試

而因為整個架構比較複雜這邊的部署要先有心理準備，大概需要 15 分鐘到 30 分鐘的時間

部署完成後 CDK 很貼心的準備好要怎麼登入 EKS 的指令直接服用就可以了！

Outputs:
CdkEksStack.eksConfigCommandDB09280A = aws eks update-kubeconfig --name eksB49B8EA3-7fcd6a64ed934f00ae43ec1cb67a87fa --region us-west-2 --role-arn arn:aws:iam::888888888888:role/CdkEksStack-mastersRole634808EE-1I504Q4EPLS70
CdkEksStack.eksGetTokenCommand8952195F = aws eks get-token --cluster-name eksB49B8EA3-7fcd6a64ed934f00ae43ec1cb67a87fa --region us-west-2 --role-arn arn:aws:iam::888888888888:role/CdkEksStack-mastersRole634808EE-1I504Q4EPLS70

設定 kubeconfig

$ aws eks update-kubeconfig --name eksB49B8EA3-7fcd6a64ed934f00ae43ec1cb67a87fa --region us-west-2 --role-arn arn:aws:iam::888888888888:role/CdkEksStack-mastersRole634808EE-1I504Q4EPLS70
Added new context arn:aws:eks:us-west-2:888888888888:cluster/eksB49B8EA3-7fcd6a64ed934f00ae43ec1cb67a87fa to /Users/clarence/.kube/config

使用 kubectl

如此執行完我們就可以使用 kubectl 指令拉！執行 get node 可以看到我們有一台機器受 EKS 管理

$ kubectl get node
NAME                                        STATUS   ROLES    AGE   VERSION
ip-10-0-255-11.us-west-2.compute.internal   Ready    <none>   14m   v1.17.11-eks-cfdc40

AWS EKS Console

我們先到 AWS Console 看看 Clusters 出現了我剛剛創建的 EKS Cluster

也可以在 EC2 看到唯一的一台 EC2 機器

• Details

  • EKS 的 Details 裡面有 API server endpoint 與其他詳細的 EKS 資料

• Compute

  • 如下可以看到 EKS 的 Compute

• Networking

  • 另外還有 Networking 裡面有 4 個 Subnets

• Logging

  • 目前我們沒有開啟 EKS 的 Logging 所以裡面都是 Disable 的

• Update history

• Tags

參考資料

• https://aws.amazon.com/tw/eks/

今天介紹 EKS 叢集如果熟悉 K8S 的朋友其實只需要如此就可以開始用一般的方法使用拉！

前面都只有介紹一個 Container 服務一個 Port 那大家是不是有一個疑問如果我的 Container 是多個 Port 的服務有沒有辦法用 ECS 嗎？答案是可以的呦！平常看到的範例都是多個 Port 就要開多個 Container 那我可以節省成本只用一個 Container 就好嗎？答案也是可以的呦！

今天就來教大家怎麼達成這件事情吧！

一個可以服務多個 Port 的程式

因為要測試多 Port 服務所以我寫了一個測試程式提供給大家測試，它可以顯示目前連線的網址與 Port 這支程式開的 Port 為：80、8080、8000 與 8888

建立 Fargate Task Definition

我們這次的 Task 與之前差不多，主要的重點是這次我們宣告了多個 container port

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef", {
  memoryLimitMiB: 512,
  cpu: 256,
});
const container = taskDefinition.addContainer("container", {
  image: ecs.ContainerImage.fromDockerImageAsset(asset),
  memoryLimitMiB: 512,
});
container.addPortMappings(
  {
    containerPort: 80,
  },
  {
    containerPort: 8888,
  },
  {
    containerPort: 8080,
  },
  {
    containerPort: 8000,
  }
);

如此在 Task Definition 就可以看到我們宣告的 Port Mappings 表

設定 ALB

我們在 ALB 上面 Listen 剛剛的 80、8080、8000 與 8888

這邊有一個新的設定是 defaultAction 我們希望他在沒有 Rules 的時候做什麼事情，在後面我特別保留了 8888 port 沒有設定，這樣就可以看到它是什麼樣子了！

要注意這個值一定要設定不然會有問題呦！

const lb = new elbv2.ApplicationLoadBalancer(this, "LB", {
  vpc,
  internetFacing: true,
});
const listener1 = lb.addListener("Listener1", {
  port: 80,
  defaultAction: elbv2.ListenerAction.fixedResponse(200, {
    contentType: elbv2.ContentType.TEXT_PLAIN,
    messageBody: "OK",
  }),
});
const listener2 = lb.addListener("Listener2", {
  port: 8080,
  defaultAction: elbv2.ListenerAction.fixedResponse(200, {
    contentType: elbv2.ContentType.TEXT_PLAIN,
    messageBody: "OK",
  }),
});
const listener3 = lb.addListener("Listener3", {
  port: 8888,
  protocol: elbv2.ApplicationProtocol.HTTP,
  defaultAction: elbv2.ListenerAction.fixedResponse(200, {
    contentType: elbv2.ContentType.TEXT_PLAIN,
    messageBody: "OK",
  }),
});
const listener4 = lb.addListener("Listener4", {
  port: 8000,
  defaultAction: elbv2.ListenerAction.fixedResponse(200, {
    contentType: elbv2.ContentType.TEXT_PLAIN,
    messageBody: "OK",
  }),
});

註冊 Targets

我們分別把 Container 的 port 都跟 Listener 對應保留剛剛說的 8888 沒有設定對應 這邊有一個重點是 containerName 一定要與建立 Fargate Task Definition時設定的一樣，因為他們是靠同一個名稱做連結的

listener1.addTargets("ECS1", {
  port: 80,
  targets: [
    service.loadBalancerTarget({
      containerName: "container",
      containerPort: 80,
    }),
  ],
});

listener2.addTargets("ECS2", {
  port: 8080,
  targets: [
    service.loadBalancerTarget({
      containerName: "container",
      containerPort: 8080,
    }),
  ],
});

listener4.addTargets("ECS4", {
  port: 8000,
  protocol: elbv2.ApplicationProtocol.HTTP,
  targets: [
    service.loadBalancerTarget({
      containerName: "container",
      containerPort: 8000,
    }),
  ],
});

targets 使用同一個 IP

由上面三張圖我們可以觀察到，我們的 ECS Container 都是同一台

觀察一下

我們可以回到 ECS 的 Service 看一下我們只有一個 Service，而且只有一個 Running 的 Task

再到 ECS Task 確定只有一個 Task 在跑

測試一下

我們可以到 ALB 的網址 http://cdkec-lb8a1-iyxzyuebmegp-816266764.us-west-2.elb.amazonaws.com:80/ 看到服務正常並且有讀到 Port

ALB 的網址 http://cdkec-lb8a1-iyxzyuebmegp-816266764.us-west-2.elb.amazonaws.com:8080/ 看到服務正常並且有讀到 Port

ALB 的網址 http://cdkec-lb8a1-iyxzyuebmegp-816266764.us-west-2.elb.amazonaws.com:8000/ 也是一樣的情況

ALB 的網址 http://cdkec-lb8a1-iyxzyuebmegp-816266764.us-west-2.elb.amazonaws.com:8888/ 因為我們剛剛做了一點手腳所以只有回應 Default 的 OK

今天是測試如果一台機器需要服務多個 Port 的範例希望有幫助到大家！

最近討論了 EC2、Spot 與 Fargate 有沒有想過我們是不是可以來一個混搭的系統呢？ 混搭系統可以讓我們的系統可以更有彈性的被控制，像是今天可能有顯卡運算資源機器的需求我們就把它掛在 EC2 上面，一般服務型態的服務可以開 EC2 與 EC2 Spot 各半，排成服務就跑在 Fargate 上，流量高的時段就開 EC2 Spot 的機器，這樣聽起來是不是很完美呢 XD ~ 所以今天就來說明怎麼建構一個如此有彈性的系統吧！

建立一個 EC2 與 Fargate 混搭的 ECS Cluster

在開始說明之前先整理一下我們的目標，我們需要擁有三種不同的機器分別是

• On-Demand Instance：t3.micro
• Spot Instance：t3.small
• Fargate

模擬服務可以在不同的機器上面運作，所以需要開三種不同的 Task 分別是

• EC2
• EC2 Spot
• Fargate

建立 ECS Cluster

首先處理 ECS Cluster 並且設定 On-Demand Instance 的 ASG 與 Spot Instance 的 ASG，分別對應到機器等級

• On-Demand Instance：t3.micro
• Spot Instance：t3.small

Fargate 不用自己控制機器所以這邊不用處理

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

const autoScalingGroup = cluster.addCapacity(
  "DefaultAutoScalingGroupCapacity",
  {
    instanceType: ec2.InstanceType.of(
      ec2.InstanceClass.T3,
      ec2.InstanceSize.MICRO
    ),
    desiredCapacity: 1,
    machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
  }
);
autoScalingGroup.scaleOnCpuUtilization("KeepCpuHalfwayLoaded", {
  targetUtilizationPercent: 50,
});

const spotAutoScalingGroup = cluster.addCapacity(
  "SpotAutoScalingGroupCapacity",
  {
    instanceType: ec2.InstanceType.of(
      ec2.InstanceClass.T3,
      ec2.InstanceSize.SMALL
    ),
    desiredCapacity: 1,
    machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
    spotPrice: "0.0104",
    spotInstanceDraining: true,
  }
);
spotAutoScalingGroup.scaleOnCpuUtilization("KeepCpuHalfwayLoaded", {
  targetUtilizationPercent: 50,
});

建立完後可以在 ECS Instances 看到有兩種不同大小的機器註冊

建立 Task Definition

使用 Constraints 約束 Task

因為要實現不同類型的機器跑不同的服務這邊介紹一個新的參數 Constraints 它可以用來對 Task 做一些約束像是機器等級系統種類是否有掛 EFS 等等或是一些自訂參數，但是目前 AWS CDK 還不支援設定設定 Attributes 所以自動參數的部分這次沒有辦法做給大家看有興趣可以參考 AWS 文件直接在 console 或是使用 command 實作

使用 TaskDefinition 定義共用 Task

除了 Constraints 這次範例還使用了一個新的 function TaskDefinition 它有一個很好用的屬性 compatibility 使用 EC2_AND_FARGATE 就可以建立一個不管是 EC2 或是 Fargate 都可以一起共用的 Task

AWS VPC

另外還有使用一個特別的 Network Mode AWS VPC 它可以把 ENI 網卡直接掛在 Container 上面，往常我們如果直接使用 EC2 部署沒有使用 Load Balance 是沒有辦法兩個 Container 使用同一個 port 的，畢竟在系統上只有一個 process 可以 bind 一個 port，而使用了 AWS VPC 就不會發生這個問題了，因為大家都可以直接使用自己的獨立網卡拉！

查看 ECS Instance Attributes

上面有提到要使用 Constraints 約束機器可是可以約束的條件要從哪裡找呢？我們可以到 AWS Console ECS 找到 EC2 Instances，在裡面選擇一台機器按下 Actions -> View/Edit Attributes 就可以看到了，如下兩張圖片是我們開設的機器 Attributes

如圖可以看到機器等級是t3.micro

如圖可以看到機器等級是t3.small

設定 Fargate Task

Fargate 雖然不受 Cluster 管理不過我們一樣要設定 Task

const fargateTaskDefinition = new ecs.FargateTaskDefinition(
  this,
  "FargateTaskDef",
  {
    cpu: 256,
    memoryLimitMiB: 512,
  }
);

可以在 Task 看到 Network Mode 設定為 awsvpc

可以看到 Constraint 裡面是空的

設定限制機器等級 t3.micro 的 Task Definition

在這邊使用了上面說的 TaskDefinition 所以需要設定 compatibility 為 EC2，不然就要如下使用 Ec2TaskDefinition 不過其實都可以

在前面我們設定 On-Demand Instance 等級為 t3.micro，所以 placementConstraints 設定機器等級限制 t3.micro

const taskDefinition = new ecs.TaskDefinition(this, "TaskDef", {
  cpu: "256",
  memoryMiB: "512",
  compatibility: ecs.Compatibility.EC2,
  networkMode: ecs.NetworkMode.AWS_VPC,
  placementConstraints: [
    ecs.PlacementConstraint.memberOf(
      "attribute:ecs.instance-type == t3.micro"
    ),
  ],
});

可以在 Task 看到 Network Mode 設定為 awsvpc

可以在 Constraint 看到限制 type 等級 t3.micro

設定限制機器等級 t3.small 的 EC2 Task Definition

而 Spot Instance 等級為 t3.small，所以在 placementConstraints 設定機器等級限制 t3.small

const spotTaskDefinition = new ecs.Ec2TaskDefinition(this, "SpotTaskDef", {
  networkMode: ecs.NetworkMode.AWS_VPC,
  placementConstraints: [
    ecs.PlacementConstraint.memberOf(
      "attribute:ecs.instance-type == t3.small"
    ),
  ],
});

可以在 Task 看到 Network Mode 設定為 awsvpc

可以在 Constraint 看到限制 type 等級 t3.small

在 ECS Tasks 檢查設定

可以在 ECS Tasks 看到上面設定的所有 Task

建立 Container

這次範例使用一樣的 image 來建立範例，不過我們分別使用了不同的 Task Definition 來限制不同的機器種類

const fargateContainer = fargateTaskDefinition.addContainer(
  "WebContainer",
  {
    image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample"),
    memoryLimitMiB: 512,
  }
);
fargateContainer.addPortMappings({
  containerPort: 80,
});

const container = taskDefinition.addContainer("WebContainer", {
  image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample"),
  memoryLimitMiB: 512,
});
container.addPortMappings({
  containerPort: 80,
});

const spotContainer = spotTaskDefinition.addContainer("WebContainer", {
  image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample"),
  memoryLimitMiB: 512,
});
spotContainer.addPortMappings({
  containerPort: 80,
});

設定 Service

建立三種不同的 Service 分別管理不同機器等級的 Task

const fatgetService = new ecs.FargateService(this, "FargateService", {
  cluster,
  taskDefinition: fargateTaskDefinition,
});

const ecsService = new ecs.Ec2Service(this, "Ec2Service", {
  cluster,
  taskDefinition,
});

const spotEcsService = new ecs.Ec2Service(this, "SpotEc2Service", {
  cluster,
  taskDefinition: spotTaskDefinition,
});

建立 ALB

為了方便測試來把三種 Service 加入一樣的 target 吧！如果混搭的目標是用不同的機器跑不同的 Service 就可以分別投入對應的 Load Balancer 拉！

const lb = new elbv2.ApplicationLoadBalancer(this, "LB", {
  vpc,
  internetFacing: true,
});
const listener = lb.addListener("Listener", { port: 80 });

listener.addTargets("ECS2", {
  port: 80,

  targets: [fatgetService, ecsService, spotEcsService],
});

測試

這次也是測試網頁而已就不多提了 XD

今天是一個機器混搭的測試，如此設定就可以在 ECS 部署上有更多的彈性

今天來介紹 ECS 使用 Fargate 它是一個由 AWS 直接管理 Container 的服務，之前介紹的 EC2 使用 ECS 需要自己管理 Host 的部分，使用了 Fargate 連 Host 都不用自己管理了，聽起來是不是很吸引人呢 ヽ(●´∀`●)ﾉ

ECS 使用 Fargate 的好處

不用管理 ECS agent

使用 Fargate 除了 Host 不用自己管理之外還有什麼好處呢？另外一個是 ECS agent 的部分，在之前的文章沒有介紹到其實 EC2 如果要跑 ECS 上面會跑有 ECS 的 Agent 而這個版本常常會更新（如左下角），如果更新就需要用右上角的 Update agent 去更新，在更新的時候其實 ECS 會把目前這台機器上所有的 Container 移走那可能就需要自己注意會不會有服務不穩定的問題，如果使用 Fargate 就不用擔心這件事情，因為 AWS 會處理好這件事情

不會有資源浪費

如果自己維護 ECS host 還會遇到像是一台機器可能有 100 vCPU 而我們今天全部的 ECS conatiner 只用到了 80 vCPU 剩下的 20 vCPU 還是需要付費的，而使用 Fargate 就沒有這個問題，因為 Fargate 計價是直接計算 vCPU 與記憶體計價的，用多少拿多少減少資源浪費

用 EC2 沒有好處嗎?

其實也不能說沒有好處，因為如果我們有特別需求需要進入 Host 查看東西或是自己有更多的調教 Host 方法這樣在 Fargate 機器上就沒有辦法實作，所以基本上還是看有需求決定應該怎麼選擇機器

CDK 使用 Fargate

定義 Cluster

就算使用 Fargate 我們還是需要一個 Cluster 來管理我們的 Fargate 機器

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

定義 Fargate Task Definition

Fargate 需要定義自己的 Task Definition 與昨天的 EC2 一樣需要先定義 Task Definition

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef");

定義 Container

今天的測試一樣使用 amazon/amazon-ecs-sample 來當測試腳本

const container = taskDefinition.addContainer("WebContainer", {
  image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample"),
  memoryLimitMiB: 512,
});
container.addPortMappings({
  containerPort: 80,
});

定義 Fargate Service

把剛剛定義好的 Cluster 與 Task Definition 組合成一個 Service

const fatgetService = new ecs.FargateService(this, "FargateService", {
  cluster,
  taskDefinition,
});

定義 ALB

為了測試需要我們還是設定一個 ALB 好讓我們在外面可直接戳 DNS 拿到結果

const lb = new elbv2.ApplicationLoadBalancer(this, "LB", {
  vpc,
  internetFacing: true,
});
const listener = lb.addListener("Listener", { port: 80 });
listener.addTargets("ECS", {
  port: 80,
  targets: [fatgetService],
});

觀察一下 ECS Instances

我們可以看一下如果是使用 Fargate 的 task 就不會在 ECS Instances 的地方看到任何機器囉！

整理一下

其實整個程式量真的很少大概 30 行就可以起一個可以用的 Web 服務而且是高可用性的真的很簡單 ~

const vpc = new ec2.Vpc(this, "Vpc", { maxAzs: 3, natGateways: 1 });

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

const taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDef");

const container = taskDefinition.addContainer("WebContainer", {
  image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample"),
  memoryLimitMiB: 512,
});
container.addPortMappings({
  containerPort: 80,
});

const fatgetService = new ecs.FargateService(this, "FargateService", {
  cluster,
  taskDefinition,
});

const lb = new elbv2.ApplicationLoadBalancer(this, "LB", {
  vpc,
  internetFacing: true,
});
const listener = lb.addListener("Listener", { port: 80 });
listener.addTargets("ECS", {
  port: 80,
  targets: [fatgetService],
});

測試 ALB

最後我們還是測試一下 ALB 的結果，可想而知一定也是正常拉 XD

今天教大家實作 Fargate 機器，其實如果是小團隊我滿推薦使用 Fargate 的因為他的價錢其實跟實際開一台一樣等級的機器差不多，而且可以減少很多麻煩事 XD ~

我們的 ECS Container 不會只有單存一個服務自己跑，通常都會需要與資料庫做一個連結，所以今天就來說明如何讓 ECS Container 與 RDS 連結

建立一個 ECS 與 RDS 關聯的 Web 服務

建立 RDS

先建立一個 RDS 與前面不一樣的地方是不直接指定密碼，而是讓 RDS 直接產生密碼到 AWS Secrets Manager，如此是比較安全的做法因為我們的程式不會保管密碼，也不會再部署的過程中看到密碼，要取得密碼就需要經過 Secrets Manager

const rdsInstance = new rds.DatabaseInstance(this, "Database", {
  engine: rds.DatabaseInstanceEngine.mysql({
    version: rds.MysqlEngineVersion.VER_8_0_19,
  }),
  vpc,
  deleteAutomatedBackups: true,
  instanceType: ec2.InstanceType.of(
    ec2.InstanceClass.BURSTABLE3,
    ec2.InstanceSize.MICRO
  ),
  allocatedStorage: 10,
  credentials: {
    username: "admin",
  },
});

要取得資料庫需要經過 Secrets Manager 而取得的過程需要使用 secretArn

new cdk.CfnOutput(this, "DatabaseSecretArn", {
  value: rdsInstance.secret!.secretArn,
});

如此資料庫的地方就完畢了

建立 ECS Cluster

因為測試使用就建立一個 ASG 就好

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

const autoScalingGroup = cluster.addCapacity(
  "DefaultAutoScalingGroupCapacity",
  {
    instanceType: ec2.InstanceType.of(
      ec2.InstanceClass.T3,
      ec2.InstanceSize.MICRO
    ),
    minCapacity: 1,
    desiredCapacity: 1,
    maxCapacity: 6,
    machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
    spotPrice: "0.0136",
    spotInstanceDraining: true,
  }
);
autoScalingGroup.scaleOnCpuUtilization("KeepCpuHalfwayLoaded", {
  targetUtilizationPercent: 50,
});

建立 Docker

這邊我們使用 DockerImageAsset 來讓本機跑一個 Dockerfile 編譯一個 Docker Image 上傳到 ECR 上面

const asset = new DockerImageAsset(this, "BuildImage", {
  directory: path.join(__dirname, "../", "image"),
});

而這邊為了方便理解 Secrets Manager 是如何讓 ECS 吃到的密碼所以我寫了一個簡單的 Web，可以用來看所有 Docker 吃進去的 environment

所以只要建立一個資料夾 image 並且下載 web-app-env 就可以了

mkdir image 
git clone https://github.com/clarencetw/web-app-env.git

Github: web-app-env

上傳成功的 Docker 可以在 ECR 看到它

建立 Task Definition

這次的 Task 主要定義了普通的 environment

• NODE_ENV

與 secret 而 secret 可以使用 ecs.Secret.fromSecretsManager(rdsInstance.secret!) 可以直接解出整個 rdsInstance.secret 的 JSON，而我這邊就直接把 rdsInstance 裡面的 JSON 直接解出來在程式使用上比較方便

• DB_ENGINE
• DB_HOST
• DB_PORT
• DB_USERNAME
• DB_PASSWORD

const taskDefinition = new ecs.Ec2TaskDefinition(this, "TaskDef");

const container = taskDefinition.addContainer("DefaultContainer", {
  image: ecs.ContainerImage.fromDockerImageAsset(asset),
  memoryLimitMiB: 16,
  logging: ecs.LogDrivers.awsLogs({ streamPrefix: "cdk-ecs" }),
  environment: {
    NODE_ENV: "production",
  },
  secrets: {
    DB_ENGINE: ecs.Secret.fromSecretsManager(rdsInstance.secret!, "engine"),
    DB_HOST: ecs.Secret.fromSecretsManager(rdsInstance.secret!, "host"),
    DB_PORT: ecs.Secret.fromSecretsManager(rdsInstance.secret!, "port"),
    DB_USERNAME: ecs.Secret.fromSecretsManager(
      rdsInstance.secret!,
      "username"
    ),
    DB_PASSWORD: ecs.Secret.fromSecretsManager(
      rdsInstance.secret!,
      "password"
    ),
  },
});
container.addPortMappings({
  containerPort: 80,
});

設定完的 Task 可以直接在 ECS 看到指定成 Secrets Manager

設定 ECS Service

const ecsService = new ecs.Ec2Service(this, "Service", {
  cluster,
  taskDefinition,
});

設定 ALB 服務

其實我們的服務只要在 CDK 建立成 service 在 LB 就很好控制了，我們只要在 targets 把 ecsService 放進去就可以了

const lb = new elbv2.ApplicationLoadBalancer(this, "LB", {
  vpc,
  internetFacing: true,
});
const listener = lb.addListener("Listener", { port: 80 });
const targetGroup = listener.addTargets("ECS", {
  port: 80,
  targets: [ecsService],
});

設定 security group

這邊要注意一下我們需要允許 ECS Service 可以存取 RDS，如果沒有設定會不能連線的

rdsInstance.connections.allowFrom(ecsService, ec2.Port.tcp(3306));

整理一下

const vpc = new ec2.Vpc(this, "Vpc", { maxAzs: 3, natGateways: 1 });

const rdsInstance = new rds.DatabaseInstance(this, "Database", {
  engine: rds.DatabaseInstanceEngine.mysql({
    version: rds.MysqlEngineVersion.VER_8_0_19,
  }),
  vpc,
  deleteAutomatedBackups: true,
  instanceType: ec2.InstanceType.of(
    ec2.InstanceClass.BURSTABLE3,
    ec2.InstanceSize.MICRO
  ),
  allocatedStorage: 10,
  credentials: {
    username: "admin",
  },
});

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

const autoScalingGroup = cluster.addCapacity(
  "DefaultAutoScalingGroupCapacity",
  {
    instanceType: ec2.InstanceType.of(
      ec2.InstanceClass.T3,
      ec2.InstanceSize.MICRO
    ),
    minCapacity: 1,
    desiredCapacity: 1,
    maxCapacity: 6,
    machineImage: ecs.EcsOptimizedImage.amazonLinux2(),
    spotPrice: "0.0136",
    spotInstanceDraining: true,
  }
);
autoScalingGroup.scaleOnCpuUtilization("KeepCpuHalfwayLoaded", {
  targetUtilizationPercent: 50,
});

const asset = new DockerImageAsset(this, "BuildImage", {
  directory: path.join(__dirname, "../", "image"),
});

const taskDefinition = new ecs.Ec2TaskDefinition(this, "TaskDef");

const container = taskDefinition.addContainer("DefaultContainer", {
  image: ecs.ContainerImage.fromDockerImageAsset(asset),
  memoryLimitMiB: 16,
  logging: ecs.LogDrivers.awsLogs({ streamPrefix: "cdk-ecs" }),
  environment: {
    NODE_ENV: "production",
  },
  secrets: {
    DB_ENGINE: ecs.Secret.fromSecretsManager(rdsInstance.secret!, "engine"),
    DB_HOST: ecs.Secret.fromSecretsManager(rdsInstance.secret!, "host"),
    DB_PORT: ecs.Secret.fromSecretsManager(rdsInstance.secret!, "port"),
    DB_USERNAME: ecs.Secret.fromSecretsManager(
      rdsInstance.secret!,
      "username"
    ),
    DB_PASSWORD: ecs.Secret.fromSecretsManager(
      rdsInstance.secret!,
      "password"
    ),
  },
});
container.addPortMappings({
  containerPort: 80,
});

const ecsService = new ecs.Ec2Service(this, "Service", {
  cluster,
  taskDefinition,
});

const lb = new elbv2.ApplicationLoadBalancer(this, "LB", {
  vpc,
  internetFacing: true,
});
const listener = lb.addListener("Listener", { port: 80 });
const targetGroup = listener.addTargets("ECS", {
  port: 80,
  targets: [ecsService],
});

rdsInstance.connections.allowFrom(ecsService, ec2.Port.tcp(3306));

今天的服務主要是教大家如何在 ECS 使用一個可以連接 RDS 的服務，希望有幫助到大家 ~