48、在AWS上构建Kubernetes

落叶知秋263

于 2025-12-11 12:38:32 发布

阅读量13

点赞数

CC 4.0 BY-SA版权

分类专栏： DevOps实战：Puppet到K8s 文章标签： AWS Kubernetes OpsWorks

本文链接：https://blog.youkuaiyun.com/ansible6ops/article/details/155924561

DevOps实战：Puppet到K8s 专栏收录该内容

52 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

在AWS上构建Kubernetes

一、在AWS上构建Kubernetes基础设施

Amazon Web Services（AWS）是最受欢迎的云服务，我们可以在亚马逊数据中心启动多个虚拟机。以下是在AWS上构建Kubernetes基础设施的详细步骤：

1. 准备工作

访问 http://aws.amazon.com 注册AWS账户，注册时需提供个人信息和信用卡号。
注册后可能需要等待长达24小时来验证账户，验证通过后登录AWS控制台。

2. 网络设置

2.1 选择区域和可用区

AWS支持多个区域的数据中心，选择最近且最便宜的区域，每个区域内有多个可用区（AZ），这些可用区是物理隔离的。

2.2 创建VPC和子网

创建VPC ：在AWS控制台访问VPC，点击“Create VPC”，输入名称标签为“My Kubernetes VPC”，CIDR为“10.0.0.0/16”。
创建子网 ：在VPC下创建多个公共子网和私有子网，以避免单点故障。具体信息如下表：
| 名称标签 | CIDR块 | 可用区 | 自动分配公共IP |
| — | — | — | — |
| My Kubernetes Public A | 10.0.0.0/24 | us - east - 1a | 是 |
| My Kubernetes Public D | 10.0.1.0/24 | us - east - 1d | 是 |
| My Kubernetes Private A | 10.0.2.0/24 | us - east - 1a | 否（默认） |
| My Kubernetes Private D | 10.0.3.0/24 | us - east - 1d | 否（默认） |
操作步骤：点击左侧导航链接中的“Subnets”，再点击“Create Subnet”按钮，填写信息并选择VPC和可用区，重复此操作四次创建四个子网。
启用公共IP自动分配 ：选择公共子网，点击“Subnet Actions”按钮，选择“Modify Auto - Assign Public IP”启用公共IP自动分配。

2.3 创建网关

每个子网都应有一个通往外部网络的网关，有两种类型的网关：
- Internet Gateway（IGW） ：允许具有公共IP地址的服务器与互联网进行双向访问。
- Network Address Translation（NAT） ：允许具有私有IP地址的服务器单向访问互联网。
创建网关的关联信息如下：
| 类型 | 关联对象 |
| — | — |
| Internet Gateway | VPC |
| NAT Gateway | 公共子网A |

2.4 配置路由表

创建路由表 ：在AWS控制台点击左侧导航窗格中的“Route Tables”，点击“Create Route Table”按钮，填写表名并选择创建的VPC，分别为公共路由和私有路由重复此过程两次。
添加默认路由 ：
- 公共路由：点击“Routes”选项卡并点击“Edit”，添加默认路由“0.0.0.0/0”，目标为IGW ID。
- 私有路由：点击“Routes”选项卡并点击“Edit”，添加默认路由“0.0.0.0/0”，目标为NAT网关ID。
关联子网 ：点击“Subnet Associations”选项卡，点击“Edit”，为公共路由选择公共子网，为私有路由选择私有子网。

2.5 配置安全组

3. 启动EC2实例

创建好VPC、子网和安全组后，即可启动EC2实例来设置自己的Kubernetes集群。EC2实例应与子网和安全组关联，具体信息如下：
| 实例 | 子网 | 安全组 |
| — | — | — |
| etcd | 私有 | My etcd SG、My ssh SG |
| Kubernetes node（带flannel） | 公共 | My flannel SG、My Kubernetes node SG、My ssh SG |
| Kubernetes master（带flannel） | 私有 | My flannel SG、My Kubernetes master SG、My ssh SG |

二、使用AWS OpsWorks管理应用程序

AWS OpsWorks是一个基于Chef（ http://chef.io/ ）的综合AWS EC2和应用程序部署框架，使用OpsWorks UI可以轻松关联Chef食谱和EC2实例。

1. 准备工作

建议准备一个GitHub（ http://github.com ）账户，用于上传和维护Chef食谱。
在GitHub上创建一个名为“my - opsworks - recipes”的仓库。

2. 上传Chef食谱示例

以AWS CloudWatchLogs为例，将食谱上传到GitHub仓库的步骤如下：

# 下载CloudWatchLogs Cookbooks
$ curl -L -O https://s3.amazonaws.com/aws-cloudwatch/downloads/CloudWatchLogs-Cookbooks.zip
# 解压
$ unzip CloudWatchLogs-Cookbooks.zip 
# 克隆GitHub仓库
$ git clone https://github.com/hidetosaito/my-opsworks-recipes.git
# 将CloudWatchLogs Cookbooks复制到Git仓库
$ mv CloudWatchLogs-Cookbooks/logs my-opsworks-recipes/
$ cd my-opsworks-recipes/
# 将食谱添加到Git
$ git add logs
$ git commit -a -m "initial import"
# 推送到GitHub.com
$ git push

3. 创建OpsWorks堆栈和层

3.1 创建OpsWorks堆栈

访问AWS Web控制台，导航到OpsWorks，点击“Add stack”进入AWS OpsWorks控制台。
填写以下信息，未提及的部分使用默认值：
- 选择Chef 11.10堆栈。
- 给堆栈命名，例如“My Kubernetes Cluster”。
- 分配为Kubernetes配置的区域和VPC。
- 操作系统选择Linux系统和最新的Amazon Linux，例如Amazon Linux 2015.09。
- 点击配置下方的“Advanced>>”，禁用“Use OpsWorks security groups”。
- 点击“Add stack”创建Kubernetes堆栈。

3.2 创建OpsWorks层

访问OpsWorks UI创建自定义层并设置层名称。
打开食谱页面，添加“logs::config”和“logs::install”食谱来设置生命周期事件。

4. 调整IAM角色

为了将日志发送到CloudWatchLogs服务，需要授予IAM角色权限：
- 访问AWS IAM控制台，选择“aws - opsworks - ec2 - role”。
- 附加“CloudWatchLogsFullAccess”策略。

5. 启动OpsWorks实例

再次访问AWS OpsWorks控制台，选择OpsWorks层启动实例。
几分钟后，实例状态将变为“online”，表示EC2实例已启动，CloudWatchLogs代理已安装完成。

6. 工作原理

对于Kubernetes设置，应定义以下层：
- Kubernetes master层
- Kubernetes node层
- etcd层

三、通过Chef食谱自动部署Kubernetes

为了在AWS OpsWorks中实现快速部署，我们可以将安装过程编写在Chef食谱中。Chef是一个基于Ruby的自动部署管理工具（ https://www.chef.io ），能帮助进行程序部署和系统配置。

1. 准备工作

基于之前构建的Kubernetes基础设施，确保VPC、子网、路由表和安全组都已准备好。
注意选择相同的AWS区域来创建ELB和安全组，因为OpsWorks虽为全局服务，但不能跨区域组合计算资源。

2. 创建ELB及其安全组

建议在etcd和Kubernetes master之上创建ELB，为其他应用层提供入口并平衡工作节点的负载。

2.1 创建ELB安全组规则

规则名称	入站协议和端口号	源
My ELB of etcd SG	80/tcp	My Kubernetes master、My Kubernetes node
My ELB of Kubernetes master SG	8080/tcp	My Kubernetes node SG

2.2 修改现有安全组规则

规则名称	入站协议和端口号	源
My etcd SG	7001/tcp、4001/tcp	My etcd SG、My ELB of etcd SG
My Kubernetes master SG	8080/tcp	My ELB of Kubernetes master SG

2.3 创建ELB

3. 创建OpsWorks堆栈

点击“Add stack”进入AWS OpsWorks控制台。
填写以下信息，未提及部分使用默认值：
- 选择Chef 12堆栈。
- 给堆栈命名，如“My Kubernetes Cluster”。
- 分配为Kubernetes配置的区域和VPC。
- 操作系统选择Linux系统和最新的Amazon Linux，如Amazon Linux 2015.09。
- 点击配置下方的“Advanced>>”，禁用“Use OpsWorks security groups”。
- 点击“Add stack”创建Kubernetes堆栈。

4. 创建应用层

5. 准备Chef食谱

在GitHub仓库中准备以下文件和相对路径：

$ tree .
.
└── kubernetes
    ├── recipes
    │   ├── docker.rb
    │   ├── etcd - run.rb
    │   ├── etcd.rb
    │   ├── flanneld.rb
    │   ├── kubernetes - master - run.rb
    │   ├── kubernetes - master - setup.rb
    │   ├── kubernetes - node - run.rb
    │   ├── kubernetes - node - setup.rb
    │   └── kubernetes.rb
    └── templates
        └── default
            ├── docker.erb
            ├── etcd.erb
            ├── flanneld.erb
            ├── kubernetes - master.erb
            └── kubernetes - node.erb
4 directories, 14 files

6. 配置堆栈以运行食谱

修改当前堆栈的设置，点击“Stack Settings”，再点击“Edit”，启用“Use custom Chef Cookbooks”，输入GitHub仓库URL。
在“Advanced options”的“Custom JSON”中输入以下信息：

{
    "kubernetes": {
        "version": "1.1.8",
        "cluster_cidr": "192.168.0.0/16",
        "master_url": "<The DNS name of my - k8s - master - elb>"
    },
    "etcd": {
        "elb_url": "<The DNS name of my - etcd - elb>"
    }
}

7. 各层的Chef食谱

7.1 etcd层食谱

etcd.rb（Setup阶段） ：

bash 'install_etcd' do
    user 'root'
    cwd '/tmp'
    code << - EOH
    if [ ! - f /usr/local/bin/etcd ]; then
        wget -- max - redirect 255 https://github.com/coreos/etcd/releases/download/v2.2.5/etcd - v2.2.5 - linux - amd64.tar.gz
        tar zxvf etcd - v2.2.5 - linux - amd64.tar.gz
        cd etcd - v2.1.1 - linux - amd64
        cp etcd etcdctl /usr/local/bin
    fi
    EOH
end
template "/etc/init.d/etcd" do
    mode "0755"
    owner "root"
    source "etcd.erb"
end

etcd - run.rb（Deploy阶段） ：

service 'etcd' do
    action [:enable, :start]
end

7.2 Kubernetes master层食谱

kubernetes.rb（Setup阶段，下载Kubernetes包） ：

bash 'install_kubernetes' do
    user 'root'
    cwd '/tmp'
    code << - EOH
    if [[ $(ls /usr/local/bin/kubectl) ]]; then
        current_version=$(/usr/local/bin/kubectl version | awk 'NR==1' | awk - F":\"v" '{ print $2 }' | awk - F"\"," '{ print $1 }')
        if [ "$current_version" - eq "#{node['kubernetes']['version']}" ]; then
            exit
        fi
    fi
    if [[ $(ls /usr/local/bin/kubelet) ]]; then
        current_version=$(/usr/local/bin/kubelet -- version | awk - F"Kubernetes v" '{ print $2 }')
        if [ "$current_version" - eq "#{node['kubernetes']['version']}" ]; then
            exit
        fi
    fi
    rm - rf kubernetes/
    wget -- max - redirect 255 https://github.com/GoogleCloudPlatform/kubernetes/releases/download/v#{node['kubernetes']['version']}/kubernetes.tar.gz - O kubernetes - #{node['kubernetes']['version']}.tar.gz
    tar zxvf kubernetes - #{node['kubernetes']['version']}.tar.gz
    cd kubernetes/server
    tar zxvf kubernetes - server - linux - amd64.tar.gz
    EOH
end

kubernetes - master - setup.rb（Setup阶段，安装主节点） ：

include_recipe 'kubernetes::kubernetes'
bash "master - file - copy" do
    user 'root'
    cwd '/tmp/kubernetes/server/kubernetes/server/bin'
    code << - EOH
    if [[ $(ls /usr/local/bin/kubectl) ]]; then
        current_version=$(/usr/local/bin/kubectl version | awk 'NR==1' | awk - F":\"v" '{ print $2 }' | awk - F"\"," '{ print $1 }')
        if [ "$current_version" - eq "#{node['kubernetes']['version']}" ]; then
            exit
        fi
    fi
    cp kubectl kube - apiserver kube - scheduler kube - controller - manager kube - proxy /usr/local/bin
    EOH
end
directory '/etc/kubernetes' do
    owner 'root'
    group 'root'
    mode '0755'
    subscribes :create, "bash[master - file - copy]", :immediately
    action :nothing
end
etcd_endpoint="http://#{node['etcd']['elb_url']}:80"
template "/etc/init.d/kubernetes - master" do
    mode "0755"
    owner "root"
    source "kubernetes - master.erb"
    variables({
        :etcd_server => etcd_endpoint,
        :cluster_cidr => node['kubernetes']['cluster_cidr']
    })
    subscribes :create, "bash[master - file - copy]", :immediately
    action :nothing
end

flanneld.rb（可选，安装flanneld） ：

bash 'install_flannel' do
    user 'root'
    cwd '/tmp'
    code << - EOH
    if [ ! - f /usr/local/bin/flanneld ]; then
        wget -- max - redirect 255 https://github.com/coreos/flannel/releases/download/v0.5.2/flannel - 0.5.2 - linux - amd64.tar.gz
        tar zxvf flannel - 0.5.2 - linux - amd64.tar.gz
        cd flannel - 0.5.2
        cp flanneld /usr/local/bin
        cp mk - docker - opts.sh /opt/
    fi
    EOH
end
template "/etc/init.d/flanneld" do
    mode "0755"
    owner "root"
    source "flanneld.erb"
    variables :elb_url => node['etcd']['elb_url']
    notifies :disable, 'service[flanneld]', :delayed
end
service "flanneld" do
    action :nothing
end

kubernetes - master - run.rb（启动服务） ：

service "flanneld" do
    action :start
end
service "kubernetes - master" do
    action :start
end

7.3 Kubernetes node层食谱

docker.rb（Setup阶段，安装Docker） ：

package "docker" do
    action :install
end
package "bridge - utils" do
    action :install
end
service "docker" do
    action :disable
end
template "/etc/sysconfig/docker" do
    mode "0644"
    owner "root"
    source "docker.erb"
end

kubernetes - node - setup.rb（Setup阶段，安装节点） ：

include_recipe 'kubernetes::kubernetes'
bash "node - file - copy" do
    user 'root'
    cwd '/tmp/kubernetes/server/kubernetes/server/bin'
    code << - EOH
    if [[ $(ls /usr/local/bin/kubelet) ]]; then
        current_version=$(/usr/local/bin/kubelet -- version | awk - F"Kubernetes v" '{ print $2 }')
        if [ "$current_version" - eq "#{node['kubernetes']['version']}" ]; then
            exit
        fi
    fi
    cp kubelet kube - proxy /usr/local/bin
    EOH
end
directory '/var/lib/kubelet' do
    owner 'root'
    group 'root'
    mode '0755'
    subscribes :create, "bash[node - file - copy]", :immediately
    action :nothing
end
directory '/etc/kubernetes' do
    owner 'root'
    group 'root'
    mode '0755'
    subscribes :create, "bash[node - file - copy]", :immediately
    action :nothing
end
template "/etc/init.d/kubernetes - node" do
    mode "0755"
    owner "root"
    source "kubernetes - node.erb"
    variables :master_url => node['kubernetes']['master_url']
    subscribes :create, "bash[node - file - copy]", :immediately
    notifies :disable, 'service[kubernetes - node]', :delayed
    action :nothing
end
service "kubernetes - node" do
    action :nothing
end

kubernetes - node - run.rb（启动服务） ：

service "flanneld" do
    action :start
    notifies :run, 'bash[wait_flanneld]', :delayed
end
bash 'wait_flanneld' do
    user 'root'
    cwd '/tmp'
    code << - EOH
    tries = 0
    while [ ! - f /run/flannel/subnet.env - a $tries - lt 10 ]; do
        sleep 1
        tries=$((tries + 1))
    done
    EOH
    action :nothing
    notifies :start, 'service[docker]', :delayed
end
service "docker" do
    action :nothing
    notifies :start, 'service[kubernetes - node]', :delayed
end
service "kubernetes - node" do
    action :nothing
end

8. 启动实例

确保etcd是最早运行的实例，Kubernetes master层可以在etcd运行后启动，因为主节点需要数据存储来获取资源信息。主节点准备好后，可根据需要创建多个节点。

综上所述，通过以上步骤，我们可以在AWS上构建Kubernetes基础设施，使用AWS OpsWorks管理应用程序，并通过Chef食谱自动部署Kubernetes，实现高效、自动化的Kubernetes集群部署。

下面是一个简单的mermaid流程图，展示自动部署Kubernetes的主要步骤：

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px;
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    classDef decision fill:#FFF6CC,stroke:#FFBC52,stroke-width:2px;

    A([开始]):::startend --> B(准备工作):::process
    B --> C(创建ELB及其安全组):::process
    C --> D(创建OpsWorks堆栈):::process
    D --> E(创建应用层):::process
    E --> F(准备Chef食谱):::process
    F --> G(配置堆栈以运行食谱):::process
    G --> H(各层的Chef食谱):::process
    H --> I(启动实例):::process
    I --> J([结束]):::startend