20、在AWS和GCP上部署Kubernetes的全攻略

最新推荐文章于 2025-10-10 04:58:40 发布

elastic6hunter

最新推荐文章于 2025-10-10 04:58:40 发布

阅读量64

点赞数

CC 4.0 BY-SA版权

分类专栏： Kubernetes与DevOps实践精要文章标签： Kubernetes AWS GCP

本文链接：https://blog.youkuaiyun.com/elastic6hunter/article/details/150002672

Kubernetes与DevOps实践精要专栏收录该内容

24 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

在AWS和GCP上部署Kubernetes的全攻略

1. AWS上的Kubernetes部署

1.1 AWS组件配置

1.1.1 ELB（弹性负载均衡器）

AWS提供了强大的基于软件的负载均衡器ELB，它可以将网络流量负载均衡到一个或多个EC2实例。此外，ELB还能卸载SSL/TLS加密/解密工作，并且支持多可用区。以下是创建ELB并关联到公共子网中运行nginx的示例：
1. 创建ELB的安全组：

$ aws ec2 create-security-group --vpc-id vpc-66eda61f --group-name elb --description "elb sg"
{
  "GroupId": "sg-51d77921"
}
$ aws ec2 authorize-security-group-ingress --group-id sg-51d77921 --protocol tcp --port 80 --cidr 0.0.0.0/0

创建ELB：

$ aws elb create-load-balancer --load-balancer-name public-elb --listeners Protocol=HTTP,LoadBalancerPort=80,InstanceProtocol=HTTP,InstancePort=80 --subnets subnet-d83a4b82 --security-groups sg-51d77921
{
   "DNSName": "public-elb-1779693260.us-east-1.elb.amazonaws.com"
}

将实例注册到ELB：

$ aws elb register-instances-with-load-balancer --load-balancer-name public-elb --instances i-0db344916c90fae61

测试ELB：

$ curl -I public-elb-1779693260.us-east-1.elb.amazonaws.com
HTTP/1.1 200 OK
Accept-Ranges: bytes
Content-Length: 3770
Content-Type: text/html
...

1.1.2 更新Route 53 DNS记录

使用CNAME将 public.k8s-devops.net 指向ELB的FQDN：

$ cat change-to-elb.json
{
  "Comment": "use CNAME to pointing to ELB",
  "Changes": [
    {
      "Action": "DELETE",
      "ResourceRecordSet": {
        "Name": "public.k8s-devops.net",
        "Type": "A",
        "TTL": 300,
        "ResourceRecords": [
          {
           "Value": "52.86.166.223"
          }
        ]
      }
    },
    {
      "Action": "UPSERT",
      "ResourceRecordSet": {
        "Name": "public.k8s-devops.net",
        "Type": "CNAME",
        "TTL": 300,
        "ResourceRecords": [
          {
           "Value": "public-elb-1779693260.us-east-1.elb.amazonaws.com"
          }
        ]
      }
    }
  ]
}
$ dig public.k8s-devops.net
; <<>> DiG 9.8.3-P1 <<>> public.k8s-devops.net
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10278
;; flags: qr rd ra; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;public.k8s-devops.net.       IN    A
;; ANSWER SECTION:
public.k8s-devops.net.  300   IN    CNAME public-elb-1779693260.us-east-1.elb.amazonaws.com.
public-elb-1779693260.us-east-1.elb.amazonaws.com. 60 IN A 52.200.46.81
public-elb-1779693260.us-east-1.elb.amazonaws.com. 60 IN A 52.73.172.171
;; Query time: 77 msec
;; SERVER: 10.0.0.1#53(10.0.0.1)
;; WHEN: Wed Aug 16 22:21:33 2017
;; MSG SIZE  rcvd: 134
$ curl -I public.k8s-devops.net
HTTP/1.1 200 OK
Accept-Ranges: bytes
Content-Length: 3770
Content-Type: text/html
...

1.1.3 S3（简单存储服务）

AWS的S3是一个有用的对象数据存储服务，与EBS不同，EC2实例不能将其作为文件系统挂载，而是使用AWS API将文件传输到S3。它具有高可用性（99.999999999%），多个实例可以同时访问。适合存储非吞吐量和随机访问敏感的文件，如配置文件、日志文件和数据文件。以下是将文件上传到S3的示例：
1. 创建S3存储桶：

$ aws s3 mb s3://k8s-devops
make_bucket: k8s-devops

复制文件到S3存储桶：

$ aws s3 cp add-record.json s3://k8s-devops/
upload: ./add-record.json to s3://k8s-devops/add-record.json
$ aws s3 cp change-to-elb.json s3://k8s-devops/
upload: ./change-to-elb.json to s3://k8s-devops/change-to-elb.json

检查S3存储桶中的文件：

$ aws s3 ls s3://k8s-devops/
2017-08-17 20:00:21        319 add-record.json
2017-08-17 20:00:28        623 change-to-elb.json

1.2 使用kops设置Kubernetes

1.2.1 安装kops

首先，需要将kops安装到你的机器上，支持Linux和macOS。kops是一个单二进制文件，建议将kops命令复制到 /usr/local/bin 。之后，创建一个用于kops操作的IAM用户和角色，具体细节可参考官方文档（https://github.com/kubernetes/kops/blob/master/docs/aws.md）。

1.2.2 运行kops

kops需要一个S3存储桶来存储配置和状态，同时使用Route 53将Kubernetes API服务器名称和etcd服务器名称注册到域名系统。以下是使用kops配置Kubernetes的参数说明：
| 参数 | 值 | 含义 |
| ---- | ---- | ---- |
| –name | my-cluster.k8s-devops.net | 在k8s-devops.net域名下设置my-cluster |
| –state | s3://k8s-devops | 使用k8s-devops S3存储桶 |
| –zones | us-east-1a | 部署到us-east-1a可用区 |
| –cloud | aws | 使用AWS作为云提供商 |
| –network-cidr | 10.0.0.0/16 | 创建新的VPC，CIDR为10.0.0.0/16 |
| –master-size | t2.large | 主节点使用EC2 t2.large实例 |
| –node-size | t2.medium | 工作节点使用EC2 t2.medium实例 |
| –node-count | 2 | 设置两个工作节点 |
| –networking | calico | 使用Calico作为覆盖网络 |
| –topology | private | 设置公共和私有子网，并将主节点和工作节点部署到私有子网 |
| –ssh-public-key | /tmp/internal_rsa.pub | 使用/tmp/internal_rsa.pub作为堡垒主机的公钥 |
| –bastion | 在公共子网创建SSH堡垒服务器 |
| –yes | 立即执行 |

运行kops创建集群的命令：

$ kops create cluster --name my-cluster.k8s-devops.net --state=s3://k8s-devops --zones us-east-1a --cloud aws --network-cidr 10.0.0.0/16 --master-size t2.large --node-size t2.medium --node-count 2 --networking calico --topology private --ssh-public-key /tmp/internal_rsa.pub --bastion --yes
I0818 20:43:15.022735   11372 create_cluster.go:845] Using SSH public key: /tmp/internal_rsa.pub
...
I0818 20:45:32.585246   11372 executor.go:91] Tasks: 78 done / 78 total; 0 can run
I0818 20:45:32.587067   11372 dns.go:152] Pre-creating DNS records
I0818 20:45:35.266425   11372 update_cluster.go:247] Exporting kubecfg for cluster
Kops has set your kubectl context to my-cluster.k8s-devops.net
Cluster is starting.  It should be ready in a few minutes.

创建过程可能需要5到10分钟，完成后，kops会更新 ~/.kube/config 指向Kubernetes API服务器。可以使用 kubectl 命令查看节点列表：

$ kubectl get nodes
NAME                          STATUS         AGE       VERSION
ip-10-0-36-157.ec2.internal   Ready,master   8m        v1.7.0
ip-10-0-42-97.ec2.internal    Ready,node     6m        v1.7.0
ip-10-0-42-170.ec2.internal   Ready,node     6m        v1.7.0

1.3 Kubernetes云提供商

使用kops设置Kubernetes时，会将Kubernetes云提供商配置为AWS。这意味着当使用Kubernetes的LoadBalancer服务时，会使用ELB；同时，它会使用Elastic Block Store（EBS）作为StorageClass。

1.3.1 L4 LoadBalancer

将Kubernetes服务公开到外部时，使用ELB是很有意义的。将服务类型设置为LoadBalancer会触发ELB的创建并将其关联到节点。以下是部署Grafana并使用LoadBalancer服务的示例：

$ cat grafana.yml
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: grafana
spec:
  replicas: 1
  template:
   metadata:
    labels:
     run: grafana
   spec:
    containers:
      - image: grafana/grafana
        name: grafana
        ports:
         - containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
  name: grafana
spec:
  ports:
    - port: 80
      targetPort: 3000
  type: LoadBalancer
  selector:
    run: grafana
$ kubectl create -f grafana.yml
deployment "grafana" created
service "grafana" created
$ kubectl get service
NAME         CLUSTER-IP       EXTERNAL-IP        PORT(S)        AGE
grafana      100.65.232.120   a5d97c8ef8575...   80:32111/TCP   11s
kubernetes   100.64.0.1       <none>             443/TCP        13m
$ aws elb describe-load-balancers | grep a5d97c8ef8575 | grep DNSName
         "DNSName": "a5d97c8ef857511e7a6100edf846f38a-1490901085.us-east-1.elb.amazonaws.com",

可以通过ELB的DNS访问Grafana： http://a5d97c8ef857511e7a6100edf846f38a-1490901085.us-east-1.elb.amazonaws.com 。也可以使用awscli更新Route 53分配CNAME，或者使用Kubernetes孵化器项目external-dns自动更新。

1.3.2 L7 LoadBalancer（ingress）

截至kops版本1.7.0，它不会开箱即用设置ingress控制器。但kops提供了一些附加组件，其中 ingress-nginx 使用AWS ELB和nginx的组合来实现Kubernetes ingress控制器。以下是安装 ingress-nginx 附加组件的步骤：
1. 安装ingress控制器：

$ kubectl create -f https://raw.githubusercontent.com/kubernetes/kops/master/addons/ingress-nginx/v1.6.0.yaml
namespace "kube-ingress" created
serviceaccount "nginx-ingress-controller" created
clusterrole "nginx-ingress-controller" created
role "nginx-ingress-controller" created
clusterrolebinding "nginx-ingress-controller" created
rolebinding "nginx-ingress-controller" created
service "nginx-default-backend" created
deployment "nginx-default-backend" created
configmap "ingress-nginx" created
service "ingress-nginx" created
deployment "ingress-nginx" created

部署nginx和echoserver使用NodePort服务：

$ kubectl run nginx --image=nginx --port=80
deployment "nginx" created
$ kubectl expose deployment nginx --target-port=80 --type=NodePort
service "nginx" exposed
$ kubectl run echoserver --image=gcr.io/google_containers/echoserver:1.4 --port=8080
deployment "echoserver" created
$ kubectl expose deployment echoserver --target-port=8080 --type=NodePort
service "echoserver" exposed

配置ingress规则：

$ cat nginx-echoserver-ingress.yaml
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: nginx-echoserver-ingress
spec:
  rules:
  - http:
      paths:
      - path: /
        backend:
          serviceName: nginx
          servicePort: 80
      - path: /echo
        backend:
          serviceName: echoserver
          servicePort: 8080

检查ingress：

$ kubectl get ing -o wide
NAME                       HOSTS     ADDRESS
PORTS     AGE
nginx-echoserver-ingress   *
a1705ab488dfa11e7a89e0eb0952587e-28724883.us-east-1.elb.amazonaws.com   80
1m

与标准的Kubernetes LoadBalancer服务相比，使用 nginx-ingress 附加组件可以将多个Kubernetes NodePort服务整合到单个ELB上，有助于更轻松地构建RESTful服务。

1.3.3 StorageClass

Kops将provisioner设置为 aws-ebs ，使用EBS作为StorageClass。以下是创建PersistentVolumeClaim的示例：

$ kubectl get storageclass
NAME            TYPE
default         kubernetes.io/aws-ebs
gp2 (default)   kubernetes.io/aws-ebs
$ cat pvc-aws.yml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-aws-1
spec:
  storageClassName: "default"
  accessModes:
    - ReadWriteOnce
  resources:
   requests:
     storage: 10Gi
$ kubectl create -f pvc-aws.yml
persistentvolumeclaim "pvc-aws-1" created
$ kubectl get pv
NAME                                       CAPACITY   ACCESSMODES
RECLAIMPOLICY   STATUS    CLAIM               STORAGECLASS   REASON    AGE
pvc-94957090-84a8-11e7-9974-0ea8dc53a244   10Gi       RWO           Delete
Bound     default/pvc-aws-1   default                  3s

这会自动创建EBS卷：

$ aws ec2 describe-volumes --filter Name=tag-value,Values="pvc-51cdf520-8576-11e7-a610-0edf846f38a6"
{
  "Volumes": [
    {
      "AvailabilityZone": "us-east-1a",
      "Attachments": [],
      "Tags": [
       {
...
     ],
       "Encrypted": false,
       "VolumeType": "gp2",
       "VolumeId": "vol-052621c39546f8096",
       "State": "available",
       "Iops": 100,
       "SnapshotId": "",
       "CreateTime": "2017-08-20T07:08:08.773Z",
       "Size": 10
       }
     ]
   }

1.4 使用kops维护Kubernetes集群

当需要更改Kubernetes配置，如节点数量和EC2实例类型时，kops可以支持这些操作。例如，将Kubernetes节点实例类型从t2.medium更改为t2.small，并将节点数量从2减少到1：
1. 编辑kops节点实例组设置：

$ kops edit ig nodes --name my-cluster.k8s-devops.net --state=s3://k8s-devops

在编辑器中更改设置：

apiVersion: kops/v1alpha2
kind: InstanceGroup
metadata:
 creationTimestamp: 2017-08-20T06:43:45Z
 labels:
  kops.k8s.io/cluster: my-cluster.k8s-devops.net
 name: nodes
spec:
 image: kope.io/k8s-1.6-debian-jessie-amd64-hvm-ebs-2017-05-02
 machineType: t2.small
 maxSize: 1
 minSize: 1
 role: Node
 subnets:
  - us-east-1a

应用设置：

$ kops update cluster --name my-cluster.k8s-devops.net --state=s3://k8s-devops --yes
I0820 00:57:17.900874    2837 executor.go:91] Tasks: 0 done / 94 total; 38
can run
I0820 00:57:19.064626    2837 executor.go:91] Tasks: 38 done / 94 total; 20
can run
...
Kops has set your kubectl context to my-cluster.k8s-devops.net
Cluster changes have been applied to the cloud.
Changes may require instances to restart: kops rolling-update cluster

执行滚动更新：

$ kops rolling-update cluster --name my-cluster.k8s-devops.net --state=s3://k8s-devops --yes
NAME              STATUS     NEEDUPDATE  READY MIN   MAX   NODES
bastions          Ready       0           1     1     1     0
master-us-east-1a Ready       0           1     1     1     1
nodes             NeedsUpdate 1           0     1     1     1
I0820 01:00:01.086564    2844 instancegroups.go:350] Stopping instance
"i-07e55394ef3a09064", node "ip-10-0-40-170.ec2.internal", in AWS ASG
"nodes.my-cluster.k8s-devops.net".

更新后，查看节点列表：

$ kubectl get nodes
NAME                          STATUS         AGE       VERSION
ip-10-0-36-157.ec2.internal   Ready,master   1h        v1.7.0
ip-10-0-58-135.ec2.internal   Ready,node     34s       v1.7.0

2. GCP上的Kubernetes部署

2.1 了解GCP

Google Cloud Platform（GCP）是由Google提供的公共云服务，在公共云行业中越来越受欢迎。它与AWS有相似的概念，如VPC、Compute Engine、Persistent Disk、Load Balancing和一些托管服务。GCP最初提供PaaS（平台即服务），用户可以直接部署应用程序，而无需启动VM。对于Kubernetes用户来说，最重要的服务是Google Container Engine（GKE），它是托管的Kubernetes服务，可减轻Kubernetes的安装、升级和管理负担，采用按需付费的方式使用Kubernetes集群。

2.2 使用GCP组件

2.2.1 访问GCP

GCP提供了Web控制台和命令行界面（CLI），两者都可以轻松控制GCP基础设施，但需要Google账户（如Gmail）。注册GCP账户后，如果想使用CLI，需要安装Cloud SDK（https://cloud.google.com/sdk/gcloud/），安装后使用以下命令进行配置：

$ gcloud init

2.2.2 VPC（虚拟专用云）

GCP的VPC与AWS的策略有所不同。在GCP中，不需要为VPC设置CIDR前缀，而是向VPC添加一个或多个子网，子网自带特定的CIDR块，因此GCP VPC被视为子网的逻辑组，子网之间可以相互通信。GCP VPC有两种模式：
- 自动模式 ：使用以下命令创建自动模式的VPC：

$ gcloud compute networks create my-auto-network --mode auto

自动模式会在每个区域创建预定义CIDR块的子网。截至2017年8月，GCP有11个区域，因此会创建11个子网。自动模式适合初学者，但无法指定CIDR前缀，且所有区域的11个子网可能不适合某些用例。
- 自定义模式 ：如果需要自定义子网的CIDR前缀，可以选择自定义模式。创建自定义模式的VPC：

$ gcloud compute networks create my-custom-network --mode custom

自定义模式的VPC不会自动创建子网，需要手动添加子网。

2.3 使用Google Container Engine（GKE）

GKE 是 GCP 提供的托管 Kubernetes 服务，使用它可以更轻松地设置和管理 Kubernetes 集群。以下是使用 GKE 创建 Kubernetes 集群的步骤：

2.3.1 启用 GKE API

在使用 GKE 之前，需要启用 Google Kubernetes Engine API。可以通过以下步骤操作：
1. 打开 Google Cloud Console（https://console.cloud.google.com/）。
2. 在搜索框中输入“Kubernetes Engine API”，然后选择该 API。
3. 点击“启用”按钮。

2.3.2 创建 GKE 集群

可以使用 gcloud 命令行工具创建 GKE 集群，以下是一个示例命令：

$ gcloud container clusters create my-gke-cluster \
    --zone us-central1-a \
    --num-nodes 3 \
    --machine-type n1-standard-1

上述命令的参数说明如下：
| 参数 | 含义 |
| ---- | ---- |
| –zone | 指定集群所在的区域，这里是 us-central1-a |
| –num-nodes | 指定集群中的节点数量，这里是 3 个 |
| –machine-type | 指定节点的机器类型，这里是 n1-standard-1 |

2.3.3 配置 kubectl

创建集群后，需要配置 kubectl 以与 GKE 集群进行交互。可以使用以下命令：

$ gcloud container clusters get-credentials my-gke-cluster --zone us-central1-a

此命令会将 kubectl 的上下文设置为新创建的 GKE 集群。

2.3.4 验证集群

使用以下命令验证集群是否正常工作：

$ kubectl get nodes

如果一切正常，应该会看到集群中的节点列表。

2.4 GKE 中的负载均衡

GKE 提供了多种负载均衡选项，包括内部负载均衡器和外部负载均衡器。以下是使用外部负载均衡器将 Kubernetes 服务公开到外部的示例：

2.4.1 创建 Deployment

首先，创建一个简单的 Deployment，例如部署一个 Nginx 应用：

$ kubectl create deployment nginx --image=nginx

2.4.2 创建 Service

将 Deployment 暴露为 Service，并将服务类型设置为 LoadBalancer，以创建外部负载均衡器：

$ kubectl expose deployment nginx --port=80 --target-port=80 --type=LoadBalancer

2.4.3 获取负载均衡器 IP

使用以下命令获取负载均衡器的外部 IP 地址：

$ kubectl get services nginx

输出中会显示负载均衡器的 EXTERNAL-IP 地址，通过该地址可以访问 Nginx 应用。

2.5 GKE 中的存储

GKE 支持多种存储选项，包括 Persistent Disk 和 Cloud Storage。以下是使用 Persistent Disk 创建 PersistentVolumeClaim 的示例：

2.5.1 创建 PersistentVolumeClaim

$ cat pvc-gke.yml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-gke-1
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

$ kubectl create -f pvc-gke.yml

2.5.2 使用 PersistentVolumeClaim

在 Deployment 中使用创建的 PersistentVolumeClaim：

$ cat nginx-pvc.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-pvc
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
        volumeMounts:
        - name: my-persistent-storage
          mountPath: /data
      volumes:
      - name: my-persistent-storage
        persistentVolumeClaim:
          claimName: pvc-gke-1

$ kubectl create -f nginx-pvc.yml

2.6 总结

在本文中，我们详细介绍了在 AWS 和 GCP 上部署 Kubernetes 的方法。在 AWS 上，我们使用 kops 工具快速搭建了 Kubernetes 集群，并配置了 ELB 负载均衡器、S3 存储服务等。在 GCP 上，我们了解了 GCP 的组件，使用 GKE 轻松创建和管理 Kubernetes 集群，同时介绍了 GKE 中的负载均衡和存储选项。

AWS 和 GCP 都是非常强大的公共云服务提供商，它们提供了丰富的功能和工具，使得 Kubernetes 的部署和管理变得更加简单和高效。无论是 AWS 的 kops 还是 GCP 的 GKE，都能帮助我们快速搭建和运行 Kubernetes 环境。在实际应用中，可以根据具体的需求和场景选择合适的云服务提供商和工具。

未来，随着 Kubernetes 和云服务的不断发展，相信会有更多的功能和特性推出，我们需要持续关注和学习，以充分利用这些技术为我们的业务服务。

以下是在 AWS 和 GCP 上部署 Kubernetes 的关键步骤对比表格：
| 步骤 | AWS | GCP |
| ---- | ---- | ---- |
| 安装工具 | 安装 kops 并创建 IAM 用户和角色 | 安装 Cloud SDK 并启用 GKE API |
| 创建集群 | 使用 kops 创建集群 | 使用 gcloud 创建 GKE 集群 |
| 负载均衡 | 使用 ELB 作为负载均衡器 | 使用 GKE 提供的负载均衡选项 |
| 存储 | 使用 S3 和 EBS 作为存储服务 | 使用 Persistent Disk 和 Cloud Storage |

mermaid 流程图展示在 AWS 和 GCP 上部署 Kubernetes 的整体流程：

graph LR
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px

    A(选择云服务提供商):::process --> B{AWS}:::process
    A --> C{GCP}:::process
    B --> D(安装 kops):::process
    D --> E(创建 IAM 用户和角色):::process
    E --> F(使用 kops 创建集群):::process
    F --> G(配置 ELB 和 S3):::process
    C --> H(安装 Cloud SDK):::process
    H --> I(启用 GKE API):::process
    I --> J(使用 gcloud 创建 GKE 集群):::process
    J --> K(配置 GKE 负载均衡和存储):::process

通过以上的介绍和对比，希望能帮助你更好地理解在 AWS 和 GCP 上部署 Kubernetes 的方法和步骤，选择适合自己的云服务和工具来搭建和管理 Kubernetes 环境。