发布日期：2024-10-08 11:40 点击次数：60
## 基于Docker和Kubernetes的企业级DevOps实践查考营一路向西
### 课程准备
1. 离线镜像包
百度：https://pan.baidu.com/s/1N1AYGCYftYGn6L0QPMWIMw 索要码：ev2h
天翼云：https://cloud.189.cn/t/ENjUbmRR7FNz
3. CentOS7.4版块以上 臆造机3台（4C+8G+50G），内网互通，可连外网
3. 课件文档
- 《查考营课件》 - 《安设手册》
4. git仓库
https://gitee.com/agagin/python-demo.git python demo表情
https://gitee.com/agagin/demo-resources.git demo表情演示需要的资源文献
### 对于本东说念主
李永信
2012-2017，云平台开发工程师，先后对接过Vmware、OpenStack、Docker平台
2017-2019， 运维开发工程师，Docker+Kubernetes的Paas平台运维开发
2019于今，DevOps工程师
8年多的时候，积蓄了一定的开发和运维训戒，跟寰球分享。
### 课程安排
2020.4.11 Docker + kubernetes
2020.4.18 DevOps平台实践
2天的时候，节律会相对快一些
小调研：
- A : 只听过docker，险些莫得docker的使用训戒- B：有一定的docker实践训戒，不熟习或者险些没用过k8s- C：对于docker和k8s王人有一定的实践训戒，想更多了解如何基于docker+k8s构建devops平台- D：其他
### 课程先容
最近的三年多时候，轻柔容器圈的话应该会知说念这样几个事情：
- 容器工夫延续火爆
- Kubernetes(k8s)成为容器编排管制的圭臬
- 国表里厂商均已入手了全面拥抱Kubernetes的转型， 无数中微型企业仍是落地 Kubernetes，或正走落地的说念路上 。基于咫尺的发展趋势不错意象，改日几年以kubernetes平台为中枢的容器运维管制、DevOps等将迎来全面的发展。
本真实践为中枢的念念想，本课程使用企业常见的基于Django + uwsgi + Nginx架构的Python Demo表情，分别请问三个事情：
- 表情的容器化
教寰球如何把公司的表情作念成容器，况且运行在docker环境中
- 使用Kubernetes集群来管制容器化的表情
带寰球一步一步部署k8s集群，并把容器化后的demo表情使用k8s来管制起来
- 使用Jenkins和Kubernetes集成，已毕demo表情的延续集成/延续托福(CI/CD)
会使用k8s管制应用生命周期后，还差临了的智力，等于如何把开发、测试、部署的经过使用自动化器具整合起来，临了一部分呢，课程会造就寰球如何优雅的使用gitlab+Jenkins+k8s构建企业级的DevOps平台
### 经过暗示
### 你将学到哪些
- Docker量度 - 如何使用Dockerfile快速构建镜像 - Docker镜像、容器、仓库的常用操作 - Docker容器的集中（Bridge下的SNAT、DNAT）
- Kubernetes量度 - 集群的快速搭建 - kubernetes的架构及使命经过 - 使用Pod适度器管制业务应用的生命周期 - 使用CoreDNS、Service和Ingress已毕工作发现、负载平衡及四层、七层集中的走访 - Kubernetes的认证授权体系- 使用EFK构建集群业务应用的日记收罗系统 - 基于Gitlab+Jenkins+k8s构建DevOps平台 - Jenkins先容及活水线的使用 - Jenkinsfile及多分支活水线的践诺应用 - Jenkins集成sonarQube、Docker、Kubernetes - 使用groovy编写sharedLibrary，已毕CI/CD经过的优化
### 第一章 走进Docker的寰宇
先容docker的前世今生，了解docker的已毕旨趣，以Django表情为例，带寰球如何编写最好的Dockerfile构建镜像。通过本章的学习，寰球会知说念docker的宗旨及基本操作，并学会构建我方的业务镜像，并通过抓包的方式掌执Docker最常用的bridge集中模式的通讯。
#### 强硬docker
###### 若何出现的
- 轻量、高效的臆造化
Docker 公司位于旧金山，原名dotCloud，底层诓骗了Linux容器工夫（在操作系统中已毕资源攻击与放手）。为了便捷创建和管制这些容器，dotCloud 开发了一套里面器具，之后被定名为“Docker”。Docker等于这样出身的。
（念念考为啥要用Linux容器工夫？）
Hypervisor： 一种运行在基础物理工作器和操作系统之间的中间软件层，可允很多个操作系统和应用分享硬件 。常见的VMware的 Workstation 、ESXi、微软的Hyper-V或者念念杰的XenServer。
Container Runtime：通过Linux内核臆造化武艺管制多个容器，多个容器分享一套操作系统内核。因此摘掉了内核占用的空间及运行所需要的耗时，使得容器极其轻量与快速。
- 软件托福过程中的环境依赖
###### 几个常识点
- 不错把应用轨范代码及运行依赖环境打包成镜像，作为托福介质，在各环境部署
- 不错将镜像（image）启动成为容器(container)，况且提供多容器的生命周期进行管制（启、停、删）
- container容器之间相互攻击，且每个容器不错竖立资源名额
- 提供轻量级臆造化功能，容器等于在宿主机中的一个个的臆造的空间，相互相互攻击，富饶寂寞
- CS架构的软件居品
###### 版块管制
- Docker 引擎主要有两个版块：企业版（EE）和社区版（CE）- 每个季度(1-3，4-6，7-9，10-12)，企业版和社区版王人会发布一个剖析版块(Stable)。社区版块会提供 4 个月的维持，而企业版块会提供 12 个月的维持- 每个月社区版还和会过 Edge 方式发布月度版- 从 2017 年第一季度入手，Docker 版块号罢免 YY.MM-xx 步地，访佛于 Ubuntu 等表情。举例，2018 年 6 月第一次发布的社区版块为 18.06.0-ce
###### 发展史
13年景立，15年入手，迎来了赶紧发展。
Docker 1.8之前，使用[LXC](https://linuxcontainers.org/fr/lxc/introduction/)，Docker在表层作念了封装， 把LXC复杂的容器创建与使用方式简化为我方的一套高唱体系。
之后，为了已毕跨平台等复杂的场景，Docker抽出了libcontainer表情，把对namespace、cgroup的操作封装在libcontainer表情里，维持不同的平台类型。
2015年6月，Docker牵头成立了 OCI（Open Container Initiative开放容器贪图）组织，这个组织的宗旨是教学起一个围绕容器的通用圭臬 。 容器步地圭臬是一种不受表层结构绑定的契约，即不限于某种特定操作系统、硬件、CPU架构、公有云等 ， 允许任何东说念主在罢免该圭臬的情况下开发应用容器工夫，这使得容器工夫有了一个更遍及的发展空间。
OCI成立后，libcontainer 交给OCI组织来珍爱，然则libcontainer中只包含了与kernel交互的库，因此基于libcontainer表情，背面又加入了一个CLI器具，况且表情更名为runC (https://github.com/opencontainers/runc )， 咫尺runC仍是成为一个功能强劲的runtime器具。
Docker也作念了架构调养。将容器运行时量度的轨范从docker daemon剥离出来，酿成了**containerd**。containerd进取为Docker Daemon提供了`gRPC接口`，使得Docker Daemon屏蔽底下的结构变化，确保原有接口向下兼容。向下通过`containerd-shim`结合`runC`，使得引擎不错寂寞升级，幸免之前Docker Daemon升级会导致通盘容器不可用的问题。
也等于说
- runC（libcontainer）是安妥OCI圭臬的一个已毕，与底层系统交互- containerd是已毕了OCI之上的容器的高档功能，比如镜像管制、容器扩充的调用等- Dockerd咫尺是最表层与CLI交互的进度，禁受cli的央求并与containerd配合
###### 小结
1. 为了管制软件托福过程中的环境依赖，同期提供一种愈加轻量的臆造化工夫，Docker出现了2. Docker是一种CS架构的软件居品，不错把代码及依赖打包成镜像，作为托福介质，况且把镜像启动成为容器，提供容器生命周期的管制3. docker-ce，每季度发布stable版块。18.06，18.09，19.034. 发展于今，docker仍是通过制定OCI圭臬对开端的表情作念了拆分，其中runC和containerd是docker的中枢表情，结合docker悉数央求的经过，对咱们深化结合docker有很大的匡助
#### 安设
###### 建立宿主机网卡转发
```powershell## 建立网卡转发，看值是否为1$ sysctl -a |grep -w net.ipv4.ip_forwardnet.ipv4.ip_forward = 1
## 若未建立，需要扩充如下$ cat <<EOF > /etc/sysctl.d/docker.confnet.bridge.bridge-nf-call-ip6tables = 1net.bridge.bridge-nf-call-iptables = 1net.ipv4.ip_forward=1EOF$ sysctl -p /etc/sysctl.d/docker.conf```
###### Yum安设建立docker
```powershell## 下载阿里源repo文献$ curl -o /etc/yum.repos.d/Centos-7.repo -7.repo$ curl -o /etc/yum.repos.d/docker-ce.repo -ce/linux/centos/docker-ce.repo
$ yum clean all && yum makecache## yum安设$ yum install -y docker-ce## 检讨源中可用版块$ yum list docker-ce --showduplicates | sort -r## 安设指定版块##yum install -y docker-ce-18.09.9
## 建立源加速## https://cr.console.aliyun.com/cn-hangzhou/instances/mirrorsmkdir -p /etc/dockervi /etc/docker/daemon.json{ "registry-mirrors" : [ "https://8xpk5wnt.mirror.aliyuncs.com"， "https://dockerhub.azk8s.cn"， "https://registry.docker-cn.com"， "https://ot2k4d59.mirror.aliyuncs.com/" ]}
## 竖立开机自启systemctl enable docker systemctl daemon-reload
## 启动dockersystemctl start docker
## 检讨docker信息docker info
## docker-clientwhich docker## docker daemonps aux |grep docker```
#### 中枢因素及常用操作详解
三大中枢因素：镜像(Image)、容器(Container)、仓库(Registry)
（先合座看下经过，再逐一演示）
###### 镜像（Image）
打包了业务代码及运行环境的包，是静态的文献，不可径直对外提供工作。
###### 容器（Container）
镜像的运行时，不错对外提供工作。骨子上讲是诓骗namespace和cgroup等工夫在宿主机中创建的寂寞的臆造空间。
###### 仓库（Registry）
- 公有仓库，Docker Hub，阿里，网易...- 独到仓库，企业里面搭建 - Docker Registry，Docker官方提供的镜像仓库存储工作 - Harbor， 是Docker Registry的更高档封装，它除了提供友好的Web UI界面，变装和用户权限管制，用户操作审计等功能 - 镜像走访地址样子 registry.devops.com/demo/hello:latest，若莫得前边的url地址，则默许寻找Docker Hub中的镜像，若莫得tag标签，则使用latest作为标签- 公有的仓库中，一般存在这样几类镜像 - 操作系统基础镜像（centos，ubuntu，suse，alpine） - 中间件（nginx，redis，mysql，tomcat） - 谈话编译环境（python，java，golang） - 业务镜像（django-demo...）
###### 操作演示
1. 解压离线包
为了保证镜像下载的速率，因此提前在一台节点下载了离线镜像包，作念解压：
```powershell $ tar zxf registry.tar.gz -C /opt $ ll /opt/registry-data total 25732 drwxr-xr-x 3 root root 4096 Apr 9 20:11 registry -rw------- 1 root root 26344448 Apr 9 22:15 registry-v2.tar ```
2. 检讨通盘镜像：
```powershell$ docker images```
2. 拉取镜像:
```powershell$ docker pull nginx:alpine```
3. 如何独一笃定镜像:
- image_id- repository:tag
```powershell$ docker imagesREPOSITORY TAG IMAGE ID CREATED SIZEnginx alpine 377c0837328f 2 weeks ago 19.7MB```
4. 导出镜像到文献中
```powershell$ docker save -o nginx-alpine.tar nginx:alpine ``` 5. 从文献中加载镜像
```powershell $ docker load -i nginx-alpine.tar ```
6. 部署镜像仓库
https://docs.docker.com/registry/
```powershell ## 使用docker镜像启动镜像仓库工作 $ docker run -d -p 5000:5000 --restart always -v /opt/registry-data/registry:/var/lib/registry --name registry registry:2 ## 默许仓库不带认证，若需要认证，参考https://docs.docker.com/registry/deploying/#restricting-access ```
假定启动镜像仓库工作的主机地址为172.21.32.6，该目次中已存在的镜像列表：
| 现镜像仓库地址 | 原镜像仓库地址 | | ------------------------------------------------------------ | ------------------------------------------------------------ | | 172.21.32.6:5000/coreos/flannel:v0.11.0-amd64 | quay.io/coreos/flannel:v0.11.0-amd64 | | 172.21.32.6:5000/mysql:5.7 | mysql:5.7 | | 172.21.32.6:5000/nginx:alpine | nginx:alpine | | 172.21.32.6:5000/centos:centos7.5.1804 | centos:centos7.5.1804 | | 172.21.32.6:5000/elasticsearch/elasticsearch:7.4.2 | docker.elastic.co/elasticsearch/elasticsearch:7.4.2 | | 172.21.32.6:5000/fluentd-es-root:v1.6.2-1.0 | gcr.io/google_containers/fluentd-elasticsearch:v2.4.0 | | 172.21.32.6:5000/kibana/kibana:7.4.2 | docker.elastic.co/kibana/kibana:7.4.2 | | 172.21.32.6:5000/kubernetesui/dashboard:v2.0.0-beta5 | kubernetesui/dashboard:v2.0.0-beta5 | | 172.21.32.6:5000/kubernetesui/metrics-scraper:v1.0.1 | kubernetesui/metrics-scraper:v1.0.1 | | 172.21.32.6:5000/kubernetes-ingress-controller/nginx-ingress-controller:0.30.0 | quay.io/kubernetes-ingress-controller/nginx-ingress-controller:0.30.0 |
7. 推送土产货镜像到镜像仓库中
```powershell $ docker tag nginx:alpine localhost:5000/nginx:alpine $ docker push localhost:5000/nginx:alpine ## 我的镜像仓库给外部走访，不可通过localhost，尝试使用内网地址172.21.16.3:5000/nginx:alpine $ docker tag nginx:alpine 172.21.16.3:5000/nginx:alpine $ docker push 172.21.16.3:5000/nginx:alpine The push refers to repository [172.21.16.3:5000/nginx] Get https://172.21.16.3:5000/v2/: http: server gave HTTP response to HTTPS client ## docker默许不允许向http的仓库地址推送，如何作念成https的，参考：https://docs.docker.com/registry/deploying/#run-an-externally-accessible-registry ## 咱们莫得的确文凭机构颁发的文凭和域名，自签名文凭需要在每个节点中拷贝文凭文献，比拟缺乏，因此咱们通过建立daemon的方式，来跳过文凭的考证： $ cat /etc/docker/daemon.json { "registry-mirrors": [ "https://8xpk5wnt.mirror.aliyuncs.com" ]， "insecure-registries": [ "172.21.16.3:5000" ] } $ systemctl restart docker $ docker push 172.21.16.3:5000/nginx:alpine $ docker images # IMAGE ID疏通，等于起笔名或者加速捷方式 REPOSITORY TAG IMAGE ID CREATED SIZE 172.21.16.3:5000/nginx alpine 377c0837328f 4 weeks ago nginx alpine 377c0837328f 4 weeks ago localhost:5000/nginx alpine 377c0837328f 4 weeks ago registry 2 708bc6af7e5e 2 months ago ```
8. 删除镜像
```powershell docker rmi nginx:alpine ```
9. 检讨容器列表
```powershell ## 检讨运奇迹态的容器列表 $ docker ps ## 检讨全部状况的容器列表 $ docker ps -a ```
10. 启动容器
```powershell ## 后台览动 $ docker run --name nginx -d nginx:alpine ##检讨run经过# ##检讨容器进度 ## 等同于在臆造机中开辟了一块攻击的寂寞的臆造空间 ## 启动容器的同期投入容器，-ti与/bin/sh或者/bin/bash配套使用，意念念未分派一个tty终局 $ docker run --name nginx -ti nginx:alpine /bin/sh （谨防：退出容器后，该容器会变成退出状况，因为容器里面的1号进度退出） ## 践诺上，在运行容器的时候，镜像地址背面跟的高唱等于是隐敝了原有的容器的CMD高唱，因此，扩充的这些高唱在容器里面等于1号进度，若该进度不存在了，那么容器就会处于退出的状况，比如，宿主机中扩充 1. echo 1，扩充完后，该高唱立马就扫尾了 2. ping www.baidu.com，扩充完后，高唱的进度会延续运行 $ docker run -d --name test_echo nginx:alpine echo 1，容器会立马退出 $ docker run -d --name test_ping nginx:alpine ping www.baidu.com，容器不会退出，然则因为莫得加-d参数，因此一直在前台运行，若ctrl+C拆开，则容器退出，因为1号进度被拆开了 ## 映射端口，把容器的端口映射到宿主机中，-p <host_port>:<container_port> $ docker run --name nginx -d -p 8080:80 nginx:alpine ## 资源放手，-cpuset-cpus用于竖立容器不错使用的 vCPU 核。-c，--cpu-shares用于竖立多个容器竞争 CPU 时，各个容器相对能分派到的 CPU 时候比例。假定有三个正在运行的容器，这三个容器中的任务王人是 CPU 密集型的。第一个容器的 cpu 分享权值是 1024，其它两个容器的 cpu 分享权值是 512。第一个容器将得到 50% 的 CPU 时候，而其它两个容器就只可各得到 25% 的 CPU 时候了。要是再添加第四个 cpu 分享值为 1024 的容器，每个容器得到的 CPU 时候将重新计较。第一个容器的CPU 时候变为 33%，其它容器分得的 CPU 时候分别为 16.5%、16.5%、33%。必须谨防的是，这个比例只消在 CPU 密集型的任务扩充时才有用。在四核的系统上，假定有四个单进度的容器，它们王人能各自使用一个核的 100% CPU 时候，不管它们的 cpu 分享权值是若干。 $ docker run --cpuset-cpus="0-3" --cpu-shares=512 --memory=500m nginx:alpine ```
11. 容器数据历久化
```powershell ## 挂载主机目次 $ docker run --name nginx -d -v /opt:/opt -v /var/log:/var/log nginx:alpine $ docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -d -v /opt/mysql/:/var/lib/mysql mysql:5.7 ## 使用volumes卷 $ docker volume ls $ docker volume create my-vol $ docker run --name nginx -d -v my-vol:/opt/my-vol nginx:alpine $ docker exec -ti nginx touch /opt/my-vol/a.txt ## 考证数据分享 $ docker run --name nginx2 -d -v my-vol:/opt/hh nginx:alpine $ docker exec -ti nginx2 ls /opt/hh/ a.txt ```
12. 投入容器或者扩充容器内的高唱
```powershell $ docker exec -ti <container_id_or_name> /bin/sh $ docker exec -ti <container_id_or_name> hostname ```
13. 主机与容器之间拷贝数据
大型游戏在线玩```powershell ## 主机拷贝到容器 $ echo '123'>/tmp/test.txt $ docker cp /tmp/test.txt nginx:/tmp $ docker exec -ti nginx cat /tmp/test.txt 123 ## 容器拷贝到主机 $ docker cp nginx:/tmp/test.txt ./ ```
14. 检讨容器日记
```powershell ## 检讨全部日记 $ docker logs nginx ## 及时检讨最新日记 $ docker logs -f nginx ## 从最新的100条入手检讨 $ docker logs --tail=100 -f nginx ```
15. 住手或者删除容器
```powershell ## 住手运行中的容器 $ docker stop nginx ## 启动退出容器 $ docker start nginx ## 删除退出容器 $ docker rm nginx ## 删除运行中的容器 $ docker rm -f nginx ```
16. 检讨容器或者镜像的明细
```powershell ## 检讨容器防卫信息，包括容器IP地址等 $ docker inspect nginx ## 检讨镜像的明细信息 $ docker inspect nginx:alpine ```
#### Django应用容器化实践
###### django表情先容
- 表情地址：https://gitee.com/agagin/python-demo.git- python3 + uwsgi + nginx + mysql
- 里面工作端口8002
###### 构建高唱
```powershell$ docker build . -t ImageName:ImageTag -f Dockerfile```
如何结合构建镜像的过程？
Dockerfile是一堆提醒，在docker build的时候，按照该提醒进行操作，最终身成咱们渴望的镜像
- FROM 指定基础镜像，必须为第一个高唱
``` 步地： FROM <image> FROM <image>:<tag> 示例： FROM mysql:5.7 谨防： tag是可选的，要是不使用tag时，会使用latest版块的基础镜像 ```
- MAINTAINER 镜像珍爱者的信息
``` 步地： MAINTAINER <name> 示例： MAINTAINER Yongxin Li MAINTAINER inspur_lyx@hotmail.com MAINTAINER Yongxin Li <inspur_lyx@hotmail.com> ```
- COPY|ADD 添加土产货文献到镜像中
``` 步地： COPY <src>... <dest> 示例： ADD hom* /mydir/ # 添加通盘以"hom"开头的文献 ADD test relativeDir/ # 添加 "test" 到 `WORKDIR`/relativeDir/ ADD test /absoluteDir/ # 添加 "test" 到 /absoluteDir/ ```
- WORKDIR 使命目次
``` 步地： WORKDIR /path/to/workdir 示例： WORKDIR /a (这时使命目次为/a) 谨防： 通过WORKDIR竖立使命目次后，Dockerfile中自后的高唱RUN、CMD、ENTRYPOINT、ADD、COPY等高唱王人会在该目次下扩充 ```
- RUN 构建镜像过程中扩充高唱
``` 步地： RUN <command> 示例： RUN yum install nginx RUN pip install django RUN mkdir test && rm -rf /var/lib/unusedfiles 谨防： RUN提醒创建的中间镜像会被缓存，并会鄙人次构建中使用。要是不想使用这些缓存镜像，不错在构建时指定--no-cache参数，如：docker build --no-cache ```
- CMD 构建容器后调用，也等于在容器启动时才进行调用
``` 步地： CMD ["executable"，"param1"，"param2"] (扩充可扩充文献，优先) CMD ["param1"，"param2"] (竖立了ENTRYPOINT，则径直调用ENTRYPOINT添加参数) CMD command param1 param2 (扩充shell里面高唱) 示例： CMD ["/usr/bin/wc"，"--help"] CMD ping www.baidu.com 谨防： CMD不同于RUN，CMD用于指定在容器启动时所要扩充的高唱，而RUN用于指定镜像构建时所要扩充的高唱。 ```
- ENTRYPOINT 竖立容器运滚动高唱，使其可扩充化
``` 步地： ENTRYPOINT ["executable"， "param1"， "param2"] (可扩充文献， 优先) ENTRYPOINT command param1 param2 (shell里面高唱) 示例： ENTRYPOINT ["/usr/bin/wc"，"--help"] 谨防： ENTRYPOINT与CMD尽头访佛，不同的是通过docker run扩充的高唱不会隐敝ENTRYPOINT，而docker run高唱中指定的任何参数，王人会被当作念参数再次传递给ENTRYPOINT。Dockerfile中只允许有一个ENTRYPOINT高唱，多指定时会隐敝前边的竖立，而只扩充临了的ENTRYPOINT提醒 ```
- ENV
``` 步地： ENV <key> <value> ENV <key>=<value> 示例： ENV myName John ENV myCat=fluffy ```
- EXPOSE
``` 步地： EXPOSE <port> [<port>...] 示例： EXPOSE 80 443 EXPOSE 8080 EXPOSE 11211/tcp 11211/udp 谨防： EXPOSE并不会让容器的端口走访到主机。要使其可走访，需要在docker run运行容器时通过-p来发布这些端口，或通过-P参数来发布EXPOSE导出的通盘端口 ```
###### Dockerfile
*dockerfiles/myblog/Dockerfile*
```dockerfile# This my first django Dockerfile# Version 1.0
# Base images 基础镜像FROM centos:centos7.5.1804
#MAINTAINER 珍爱者信息LABEL maintainer="inspur_lyx@hotmail.com"
#ENV 竖立环境变量 ENV LANG en_US.UTF-8 ENV LC_ALL en_US.UTF-8
#RUN 扩充以下高唱RUN curl -so /etc/yum.repos.d/Centos-7.repo -7.repoRUN yum install -y python36 python3-devel gcc pcre-devel zlib-devel make net-tools
#使命目次WORKDIR /opt/myblog
#拷贝文献至使命目次COPY . .
#安设nginxRUN tar -zxf nginx-1.13.7.tar.gz -C /opt && cd /opt/nginx-1.13.7 && ./configure --prefix=/usr/local/nginx \&& make && make install && ln -s /usr/local/nginx/sbin/nginx /usr/bin/nginx
RUN cp myblog.conf /usr/local/nginx/conf/myblog.conf
#安设依赖的插件RUN pip3 install -i --trusted-host mirrors.aliyun.com -r requirements.txt
RUN chmod +x run.sh && rm -rf ~/.cache/pip
#EXPOSE 映射端口EXPOSE 8002
#容器启动时扩充高唱CMD ["./run.sh"]```
扩充构建：
```powershell$ docker build . -t myblog:v1 -f Dockerfile```
###### 定制化基础镜像
`dockerfiles/myblog/Dockerfile-base`
```dockerfile# Base images 基础镜像FROM centos:centos7.5.1804
#MAINTAINER 珍爱者信息LABEL maintainer="inspur_lyx@hotmail.com"
#ENV 竖立环境变量ENV LANG en_US.UTF-8ENV LC_ALL en_US.UTF-8
#RUN 扩充以下高唱RUN curl -so /etc/yum.repos.d/Centos-7.repo -7.repoRUN yum install -y python36 python3-devel gcc pcre-devel zlib-devel make net-tools
COPY nginx-1.13.7.tar.gz /opt
#安设nginxRUN tar -zxf /opt/nginx-1.13.7.tar.gz -C /opt && cd /opt/nginx-1.13.7 && ./configure --prefix=/usr/local/nginx && make && make install && ln -s /usr/local/nginx/sbin/nginx /usr/bin/nginx```
```powershell## 构建基础镜像$ docker build . -t centos-python3-nginx:v1 -f Dockerfile-base$ docker tag centos-python3-nginx:v1 172.21.32.6:5000/base/centos-python3-nginx:v1$ docker push 172.21.32.6:5000/base/centos-python3-nginx:v1```
###### 简化Dockerfile
`dockerfiles/myblog/Dockerfile-optimized`
```dockerfile# This my first django Dockerfile# Version 1.0
# Base images 基础镜像FROM centos-python3-nginx:v1
#MAINTAINER 珍爱者信息LABEL maintainer="inspur_lyx@hotmail.com"
#使命目次WORKDIR /opt/myblog
#拷贝文献至使命目次COPY . .
RUN cp myblog.conf /usr/local/nginx/conf/myblog.conf
#安设依赖的插件RUN pip3 install -i --trusted-host mirrors.aliyun.com -r requirements.txt
RUN chmod +x run.sh && rm -rf ~/.cache/pip
#EXPOSE 映射端口EXPOSE 8002
#容器启动时扩充高唱CMD ["./run.sh"]```
```powershell$ docker build . -t myblog -f Dockerfile-optimized```
###### 运行mysql
```powershell$ docker run -d -p 3306:3306 --name mysql -v /opt/mysql/mysql-data/:/var/lib/mysql -e MYSQL_DATABASE=myblog -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
## 检讨数据库$ docker exec -ti mysql bash#/ mysql -uroot -p123456#/ show databases;
## navicator结合```
###### 启动Django应用
```powershell## 启动容器$ docker run -d -p 8002:8002 --name myblog -e MYSQL_HOST=172.21.32.6 -e MYSQL_USER=root -e MYSQL_PASSWD=123456 myblog
## migrate$ docker exec -ti myblog bash#/ python3 manage.py makemigrations#/ python3 manage.py migrate#/ python3 manage.py createsuperuser
## 创建超等用户$ docker exec -ti myblog python3 manage.py createsuperuser
## 收罗静态文献## $ docker exec -ti myblog python3 manage.py collectstatic```
走访62.234.214.206:8002/admin
构建镜像，替换默许编码：
`dockerfiles/mysql/my.cnf`
```powershell$ cat my.cnf[mysqld]user=rootcharacter-set-server=utf8lower_case_table_names=1
[client]default-character-set=utf8[mysql]default-character-set=utf8
!includedir /etc/mysql/conf.d/!includedir /etc/mysql/mysql.conf.d/```
`dockerfiles/mysql/Dockerfile`
```dockerfileFROM mysql:5.7COPY my.cnf /etc/mysql/my.cnf## CMD或者ENTRYPOINT默许剿袭```
```powershell$ docker build . -t mysql:5.7-utf8$ docker tag mysql:5.7-utf8 172.21.16.3:5000/mysql:5.7-utf8$ docker push 172.21.16.3:5000/mysql:5.7-utf8
## 删除旧的mysql容器，使用新镜像启动，不必再次运滚动$ docker rm -f mysql$ rm -rf /opt/mysql/mysql-data/*$ docker run -d -p 3306:3306 --name mysql -v /opt/mysql/mysql-data/:/var/lib/mysql -e MYSQL_DATABASE=myblog -e MYSQL_ROOT_PASSWORD=123456 172.21.32.6:5000/mysql:5.7-utf8
## 重新migrate$ docker exec -ti myblog bash#/ python3 manage.py makemigrations#/ python3 manage.py migrate#/ python3 manage.py createsuperuser```
#### 已毕旨趣 录屏！！！
臆造化中枢需要管制的问题：资源攻击与资源放手
- 臆造机硬件臆造化工夫， 通过一个 hypervisor 层已毕对资源的澈底攻击。- 容器则是操作系统级别的臆造化，诓骗的是内核的 Cgroup 和 Namespace 特点，此功能富饶通过软件已毕。
###### Namespace 资源攻击
定名空间是全局资源的一种笼统，将资源放到不同的定名空间中，各个定名空间中的资源是相互攻击的。 平日来讲，等于docker在启动一个容器的时候，会调用Linux Kernel Namespace的接口，来创建一块臆造空间，创建的时候，不错维持竖立底下这几种（不错玩忽选拔），docker默许王人竖立。
- pid：用于进度攻击（PID：进度ID）- net：管制集中接口（NET：集中）- ipc：管制对 IPC 资源的走访（IPC：进度间通讯（信号量、音信部队和分享内存））- mnt：管制文献系统挂载点（MNT：挂载）- uts：攻击主机名和域名- user：攻击用户和用户组（3.8以后的内核才维持）
```gofunc setNamespaces(daemon *Daemon， s *specs.Spec， c *container.Container) error { // user // network // ipc // uts // pid if c.HostConfig.PidMode.IsContainer() { ns := specs.LinuxNamespace{Type: "pid"} pc， err := daemon.getPidContainer(c) if err != nil { return err } ns.Path = fmt.Sprintf("/proc/%d/ns/pid"， pc.State.GetPID()) setNamespace(s， ns) } else if c.HostConfig.PidMode.IsHost() { oci.RemoveNamespace(s， specs.LinuxNamespaceType("pid")) } else { ns := specs.LinuxNamespace{Type: "pid"} setNamespace(s， ns) } return nil}```
###### CGroup 资源放手
通过namespace不错保证容器之间的攻击，然则无法适度每个容器不错占用若干资源， 要是其中的某一个容器正在扩充 CPU 密集型的任务，那么就会影响其他容器中任务的性能与扩充服从，导致多个容器相互影响况且霸占资源。如何对多个容器的资源使用进行放手就成了管制进度臆造资源攻击之后的主要问题。
Control Groups（简称 CGroups）等于能够攻击宿主机器上的物理资源，举例 CPU、内存、磁盘 I/O 和集中带宽。每一个 CGroup 王人是一组被疏通的圭臬和参数放手的进度。而咱们需要作念的，其实等于把容器这个进度加入到指定的Cgroup中。深化结合CGroup，请[点此]()。
###### UnionFS 斡旋文献系统
Linux namespace和cgroup分别管制了容器的资源攻击与资源放手，那么容器是很轻量的，时时每台机器中不错运行几十上百个容器， 这些个容器是共用一个image，照旧各自将这个image复制了一份，然后各自寂寞运行呢？ 要是每个容器之间王人是全量的文献系统拷贝，那么会导致至少如下问题：
- 运行容器的速率会变慢- 容器和镜像对宿主机的磁盘空间的压力
若何管制这个问题------Docker的存储驱动
- 镜像分层存储- UnionFS
Docker 镜像是由一系列的层构成的，每层代表 Dockerfile 中的一条提醒，比如底下的 Dockerfile 文献：
```dockerfileFROM ubuntu:15.04COPY . /appRUN make /appCMD python /app/app.py```
这里的 Dockerfile 包含4条高唱，其中每一瞥就创建了一层，底下表现了上述Dockerfile构建出来的镜像运行的容器层的结构：
镜像等于由这些层一层一层堆叠起来的，镜像中的这些层王人是只读的，当咱们运行容器的时候，就不错在这些基础层至上添加新的可写层，也等于咱们时时说的`容器层`，对于运行中的容器所作念的通盘改革（比如写入新文献、修改现存文献、删除文献）王人将写入这个容器层。
对容器层的操作，主要诓骗了写时复制（CoW）工夫。CoW等于copy-on-write，走漏只在需要写时才去复制，这个是针对已有文献的修改场景。 CoW工夫不错让通盘的容器分享image的文献系统，所罕有据王人从image中读取，只消当要对文献进行写操作时，才从image里把要写的文献复制到我方的文献系统进行修改。是以岂论有若干个容器分享并吞个image，所作念的写操作王人是对从image中复制到我方的文献系统中的复本上进行，并不会修改image的源文献，且多个容器操作并吞个文献，会在每个容器的文献系统里生成一个复本，每个容器修改的王人是我方的复本，相互攻击，相互不影响。使用CoW不错灵验的擢升磁盘的诓骗率。
镜像中每一层的文献王人是分散在不同的目次中的，如何把这些不同目次的文献整合到悉数呢？
UnionFS 其实是一种为 Linux 操作系统想象的用于把多个文献系统斡旋到并吞个挂载点的文献系统工作。 它能够将不同文献夹中的层斡旋（Union）到了并吞个文献夹中，悉数斡旋的过程被称为斡旋挂载（Union Mount）。
上图是AUFS的已毕，AUFS是作为Docker存储驱动的一种已毕，Docker 还维持了不同的存储驱动，包括 aufs、devicemapper、overlay2、zfs 和 Btrfs 等等，在最新的 Docker 中，overlay2 取代了 aufs 成为了保举的存储驱动，然则在莫得 overlay2 驱动的机器上仍然会使用 aufs 作为 Docker 的默许驱动。
#### Docker集中 录屏！！！
docker容器是一块具有攻击性的臆造系统，容器内不错有我方寂寞的集中空间，
- 多个容器之间是如何已毕通讯的呢？- 容器和宿主机之间又是如何已毕的通讯呢？- 使用-p参数是若何已毕的端口映射?
带着咱们就这些问题，咱们来学习一下docker的集中模子，临了我和会过抓包的方式，给寰球演示一下数据包在容器和宿主机之间的改革过程。
##### 集中模式
咱们在使用docker run创建Docker容器时，不错用--net选项指定容器的集中模式，Docker有以下4种集中模式：
- bridge模式，使用--net=bridge指定，默许竖立
- host模式，使用--net=host指定，容器里面集中空间分享宿主机的空间，后果访佛径直在宿主机上启动一个进度，端口信息和宿主机共用。
- container模式，使用--net=container:NAME_or_ID指定
指定容器与特定容器分享集中定名空间
- none模式，使用--net=none指定
集中模式为空，即仅保留集中定名空间，然则不作念任何集中量度的建立(网卡、IP、路由等)
##### bridge模式
那咱们之前在演示创建docker容器的时候其实是莫得指定的集中模式的，要是不指定的话默许就会使用bridge模式，bridge本意是桥的意念念，其实等于网桥模式，那咱们若何结合网桥，要是需要作念类比的话，咱们不错把网桥算作一个二层的交换机开拓，咱们来看下这张图：
交换机通讯简图
网桥模式暗示图
网桥在哪，检讨网桥
```powershell$ yum install -y bridge-utils$ brctl showbridge name bridge id STP enabled interfacesdocker0 8000.0242b5fbe57b no veth3a496ed```
有了网桥之后，那咱们看下docker在启动一个容器的时候作念了哪些事情才能已毕容器间的互联互通
Docker 创建一个容器的时候，会扩充如下操作：
- 创建一双臆造接口/网卡，也等于veth pair；- 土产货主机一端桥接 到默许的 docker0 或指定网桥上，并具有一个独一的名字，如 veth9953b75；- 容器一端放到新启动的容器里面，并修更名字作为 eth0，这个网卡/接口只在容器的定名空间可见；- 从网桥可用地址段中（也等于与该bridge对应的network）赢得一个幽静地址分派给容器的 eth0- 建立默许路由到网桥
那悉数过程其实是docker自动帮咱们完成的，清算掉通盘容器，来考证。
```powershell## 清掉通盘容器$ docker rm -f `docker ps -aq`$ docker ps$ brctl show # 检讨网桥中的接口，咫尺莫得
## 创建测试容器test1$ docker run -d --name test1 nginx:alpine$ brctl show # 检讨网桥中的接口，仍是把test1的veth端接入到网桥中$ ip a |grep veth # 已在宿主机中不错检讨到$ docker exec -ti test1 sh / # ifconfig # 检讨容器的eth0网卡及分派的容器ip/ # route -n # 不雅察默许网关王人指向了网桥的地址，即通盘流量王人转向网桥，等于是在veth pair接通了网线Kernel IP routing tableDestination Gateway Genmask Flags Metric Ref Use Iface0.0.0.0 172.17.0.1 0.0.0.0 UG 0 0 0 eth0172.17.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0
# 再来启动一个测试容器，测试容器间的通讯$ docker run -d --name test2 nginx:alpine$ docker exec -ti test sh/ # sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories/ # apk add curl/ # curl 172.17.0.8:80
## 为啥不错通讯，因为两个容器是接在并吞个网桥中的，通讯其实是通过mac地址和端口的的纪录来作念转发的。test1走访test2，通过test1的eth0发送ARP播送，网桥会珍爱一份mac映射表，咱们不错好像通过高唱来看一下，$ brctl showmacs docker0## 这些mac地址是主机端的veth网卡对应的mac，不错检讨一下$ ip a
```
咱们如何知说念网桥上的这些臆造网卡与容器端是如何对应？
通过ifindex，网卡索引号
```powershell## 检讨test1容器的网卡索引$ docker exec -ti test1 cat /sys/class/net/eth0/ifindex
## 主机中找到臆造网卡背面这个@ifxx的值，要是是并吞个值，阐发这个臆造网卡和这个容器的eth0网卡是配对的。$ ip a |grep @if```
整理剧本，快速检讨对应：
```powershellfor container in $(docker ps -q); do iflink=`docker exec -it $container sh -c 'cat /sys/class/net/eth0/iflink'` iflink=`echo $iflink|tr -d '\r'` veth=`grep -l $iflink /sys/class/net/veth*/ifindex` veth=`echo $veth|sed -e 's;^.*net/\(.*\)/ifindex$;\1;'` echo $container:$vethdone```
上头咱们老师了容器之间的通讯，那么容器与宿主机的通讯是如何作念的？
添加端口映射：
```powershell## 启动容器的时候通过-p参数添加宿主机端口与容器里面工作端口的映射$ docker run --name test -d -p 8088:80 nginx:alpine$ curl localhost:8088```
端口映射如何已毕的？先来去首iptables链表图
走访本机的8088端口，数据包会从流入场所投入本机，因此触及到PREROUTING和INPUT链，咱们是通过作念宿主机与容器之间加的端口映射，是以信赖会触及到端口改革，那哪个表是讲求存储端口改革信息的呢，等于nat表，讲求珍爱集中地址改革信息的。因此咱们来检讨一下PREROUTING链的nat表：
```powershell$ iptables -t nat -nvL PREROUTINGChain PREROUTING (policy ACCEPT 159 packets， 20790 bytes) pkts bytes target prot opt in out source destination 3 156 DOCKER all -- * * 0.0.0.0/0 0.0.0.0/0 ADDRTYPE match dst-type LOCAL```
法例诓骗了iptables的addrtype拓展，匹配集中类型为土产货的包，如何笃定哪些是匹配土产货，
```powershell$ ip route show table local type locallocal 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1local 172.17.0.1 dev docker0 proto kernel scope host src 172.17.0.1local 192.168.136.133 dev ens33 proto kernel scope host src 192.168.136.133```
也等于说磋磨地址类型匹配到这些的，会转发到咱们的TARGET中，TARGET是动作，意味着对安妥条款的数据包扩充什么样的操作，最常见的为ACCEPT或者DROP，此处的TARGET为DOCKER，很显着DOCKER不是圭臬的动作，那DOCKER是什么呢？咱们时时会界说自界说的链，这样把某类对应的法例放在自界说链中，然后把自界说的链绑定到圭臬的链路中，因此此处DOCKER 是自界说的链。那咱们当今就来看一下DOCKER这个自界说链上的法例。
```powershell$ iptables -t nat -nvL DOCKERChain DOCKER (2 references) pkts bytes target prot opt in out source destination 0 0 RETURN all -- docker0 * 0.0.0.0/0 0.0.0.0/0 0 0 DNAT tcp -- !docker0 * 0.0.0.0/0 0.0.0.0/0 tcp dpt:8088 to:172.17.0.2:80
```
此条法例等于对主机收到的宗旨端口为8088的tcp流量进行DNAT改革，将流量发往172.17.0.2:80，172.17.0.2地址是不是等于咱们上头创建的Docker容器的ip地址，流量走到网桥上了，背面就走网桥的转发就ok了。是以，外界只需走访192.168.136.133:8088就不错走访到容器中的工作了。
数据包在出口场所走POSTROUTING链，咱们检讨一下法例：
```powershell$ iptables -t nat -nvL POSTROUTINGChain POSTROUTING (policy ACCEPT 1099 packets， 67268 bytes) pkts bytes target prot opt in out source destination 86 5438 MASQUERADE all -- * !docker0 172.17.0.0/16 0.0.0.0/0 0 0 MASQUERADE tcp -- * * 172.17.0.4 172.17.0.4 tcp dpt:80```
寰球谨防MASQUERADE这个动作是什么意念念，其实是一种更机动的SNAT，把源地址改革成主机的出口ip地址，那阐发注解一下这条法例的意念念:
这条法例会将源地址为172.17.0.0/16的包（也等于从Docker容器产生的包），况且不是从docker0网卡发出的，进行源地址改革，改革成主机网卡的地址。好像的过程等于ACK的包在容器里面发出来，会路由到网桥docker0，网桥凭据宿主机的路由法例会转给宿主机网卡eth0，这时候包就从docker0网卡转到eth0网卡了，并从eth0网卡发出去，这时候这条法例就会奏效了，把源地址换成了eth0的ip地址。
> 谨防一下，刚才这个过程触及到了网卡间包的传递，那一定要灵通主机的ip_forward转发工作，要否则包转不了，工作信赖走访不到。>
###### 抓包演示
咱们先想一下，咱们要抓哪个网卡的包
- 开端走访宿主机的8088端口，咱们抓一下宿主机的eth0
```powershell $ tcpdump -i eth0 port 8088 -w host.cap ```
- 然后最终包会流入容器内，那咱们抓一下容器内的eth0网卡
```powershell # 容器内安设一下tcpdump $ sed -i 's/dl-cdn.alpinelinux.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apk/repositories $ apk add tcpdump $ tcpdump -i eth0 port 80 -w container.cap ```
到另一台机器走访一下，
```powershell$ curl 172.21.32.6:8088/```
住手抓包，拷贝容器内的包到宿主机
```powershell$ docker cp test:/root/container.cap /root/```
把抓到的内容拷贝到土产货，使用wireshark进行分析。
```powershell$ scp root@172.21.32.6:/root/*.cap /d/packages```
（wireshark合并包进行分析）
进到容器内的包作念DNAT，出去的包作念SNAT，这样对外面来讲，根底就不知说念机器里面是谁提供工作，其实这就和一个内网多个机器公用一个外网IP地址上网的后果是一样的，对吧，那这也属于NAT功能的一个常见的应用场景。
##### Host模式
容器里面不会创建集中空间，分享宿主机的集中空间
```powershell$ docker run --net host -d --name mysql mysql:5.7```
##### Conatiner模式
这个模式指定新创建的容器和仍是存在的一个容器分享一个 Network Namespace，而不是和宿主机分享。新创建的容器不会创建我方的网卡，建立我方的 IP，而是和一个指定的容器分享 IP、端口范围等。相通，两个容器除了集中方面，其他的如文献系统、进度列表等照旧攻击的。两个容器的进度不错通过 lo 网卡开拓通讯。
```powershell## 启动测试容器，分享mysql的集中空间$ docker run -ti --rm --net=container:mysql busybox sh/ # ip a/ # netstat -tlp|grep 3306/ # telnet localhost 3306```
#### 实用手段
1. 清算主机上通盘退出的容器
```powershell $ docker rm $(docker ps -aq) ```
2. 调试或者排查容器启动伪善
```powershell ## 若未必际遇容器启动失败的情况，不错先使用疏通的镜像启动一个临时容器，先投入容器 $ docker exec -ti --rm <image_id> bash ## 投入容器后，手动扩充该容器对应的ENTRYPOINT或者CMD高唱，这样即使出错，容器也不会退出，因为bash作为1号进度，咱们只消不退出容器，该容器就不会自动退出 ```
#### 本章小结
1. 为了管制软件托福过程中的环境依赖，同期提供一种愈加轻量的臆造化工夫，Docker出现了
2. 2013年出身，15年入手迅速发展，从17.03月入手，使用时候日历管制版块，剖析版以每季度为准
3. Docker是一种CS架构的软件居品，不错把代码及依赖打包成镜像，作为托福介质，况且把镜像启动成为容器，提供容器生命周期的管制
4. 使用yum部署docker，启动后通过操作docker这个高唱行，自动调用docker daemon完成容器量度操作
5. 常用操作
- systemctl start|stop|restart docker - docker build | pull -> docker tag -> docker push - docker run --name my-demo -d -p 8080:80 -v /opt/data:/data demo:v20200327 - docker cp /path/a.txt mycontainer:/opt - docker exec -ti mycontainer /bin/sh - docker logs -f mycontainer
6. 通过dockerfile构建业务镜像，先使用基础镜像，然后通过一系列的提醒把咱们的业务应用所需要的运行环境和依赖王人打包到镜像中，然后通过CMD或者ENTRYPOINT提醒把镜像启动时的进口制定好，完成封装即可。有点访佛于，先找来一个空的集装箱(基础镜像)，然后把表情依赖的工作王人扔到集装箱中，然后竖立好工作的启动进口，关闭箱门，即完成了业务镜像的制作。
7. 容器的已毕依赖于内核模块提供的namespace和control-group的功能，通过namespace创建一块臆造空间，空间内已毕了万般资源(进度、集中、文献系统)的攻击，提供control-group已毕了对攻击的空间的资源使用的放手。
8. docker镜像使用分层的方式进行存储，凭据主机的存储驱动的不同，已毕方式会不同，kernel在3.10.0-514以上自动维持overlay2 存储驱动，亦然咫尺Docker保举的方式。
9. 收货于分层存储的模式，多个容器不错通过copy-on-write的战略，在镜像的最表层加一个可写层，已毕一个镜像快速启动多个容器的场景
10. docker的集中模式分为4种，最常用的为bridge和host模式。bridge模式通过docker0网桥，启动容器的时候通过创建一双臆造网卡，将容器结合在桥上，同期珍爱了臆造网卡与网桥端口的关联，已毕容器间的通讯。容器与宿主机之间的通讯通过iptables端口映射的方式，docker诓骗iptables的PREROUTING和POSTROUTING的nat功能，已毕了SNAT与DNAT，使得容器里面的工作被完竣的保护起来。
### 第二章 Kubernetes实践之旅 录屏！！！
本章学习kubernetes的架构及使命经过，重心先容如何使用Deployment管制Pod生命周期，已毕工作不中断的滚动更新，通过工作发现来已毕集群里面的工作间走访，并通过ingress-nginx已毕外部使用域名走访集群里面的工作。同期先容基于EFK如何搭建Kubernetes集群的日记收罗系统。
学完本章，咱们的Django demo表情仍是不错运行在k8s集群中，同期咱们不错使用域名进行工作的走访。
- 架构及中枢组件先容- 使用kubeadm快速搭建集群- 运行第一个Pod应用- Pod进阶- Pod适度器的使用- 已毕工作与Node绑定的几种方式- 负载平衡与工作发现- 使用Ingress已毕集群工作的7层代理- Django表情k8s落地实践- 基于EFK已毕kubernetes集群的日记平台（彭胀）- 集群认证与授权
#### 纯容器模式的问题
1. 业务容器数目宏大，哪些容器部署在哪些节点，使用了哪些端口，如何纪录、管制，需要登录到每台机器去管制？2. 跨主机通讯，多个机器中的容器之间相互调用如何作念，iptables法例手动珍爱？3. 跨主机容器间相互调用，建立如何写？写死固定IP+端口？4. 如何已毕业务高可用？多个容器对外提供工作如何已毕负载平衡？5. 容器的业务中断了，如何不错感知到，感知到以后，如何自动启动新的容器?6. 如何已毕滚动升级保证业务的连气儿性？7. ......
#### 容器调动管制平台
Docker Swarm Mesos Google Kubernetes
2017年入手Kubernetes凭借强劲的容器集群管制功能， 冉冉占据商场，咫尺在容器编排范畴独步天下
https://kubernetes.io/
#### 架构图
区别组件与资源
#### 中枢组件
- ETCD：分散式高性能键值数据库，存储悉数集群的通盘元数据
- ApiServer: API工作器，集群资源走访适度进口，提供restAPI及安全走访适度
- Scheduler：调动器，讲求把业务容器调动到最合适的Node节点
- Controller Manager：适度器管制，确保集群资源按照渴望的方式运行 - Replication Controller - Node controller - ResourceQuota Controller - Namespace Controller - ServiceAccount Controller - Tocken Controller - Service Controller - Endpoints Controller
- kubelet：运行在每运行在每个节点上的主要的“节点代理”个节点上的主要的“节点代理” - pod 管制：kubelet 依期从所监听的数据源赢得节点上 pod/container 的渴望状况（运行什么容器、运行的副本数目、集中或者存储如何建立等等），并调用对应的容器平台接口达到这个状况。 - 容器健康检验：kubelet 创建了容器之后还要检讨容器是否正常运行，要是容器运行出错，就要凭据 pod 竖立的重启战略进行处理. - 容器监控：kubelet 会监控所在节点的资源使用情况，并定时向 master 答复，资源使用数据王人是通过 cAdvisor 赢得的。知说念悉数集群通盘节点的资源情况，对于 pod 的调动和正常运行至关遑急- kubectl: 高唱行接口，用于对 Kubernetes 集群运行高唱 https://kubernetes.io/zh/docs/reference/kubectl/ - CNI已毕: 通用集中接口， 咱们使用flannel来作为k8s集群的集中插件， 已毕跨节点通讯
#### 使命经过
1. 用户准备一个资源文献（纪录了业务应用的称号、镜像地址等信息），通过调用APIServer扩充创建Pod2. APIServer收到用户的Pod创建央求，将Pod信息写入到etcd中3. 调动器通过list-watch的方式，发现存新的pod数据，然则这个pod还莫得绑定到某一个节点中4. 调动器通过调动算法，计较出最允洽该pod运行的节点，并调用APIServer，把信息更新到etcd中5. kubelet相通通过list-watch方式，发现存新的pod调动到本机的节点了，因此调用容器运行时，去凭据pod的刻画信息，拉取镜像，启动容器，同期生成事件信息6. 同期，把容器的信息、事件及状况也通过APIServer写入到etcd中
#### 实践--集群安设 录屏！！！
kubeadm https://kubernetes.io/zh/docs/reference/setup-tools/kubeadm/kubeadm/
《Kubernetes安设手册（非高可用版）》
###### 中枢组件
静态Pod的方式：
```powershell## etcd、apiserver、controller-manager、kube-scheduler$ kubectl -n kube-system get po```
systemd工作方式：
```powershell$ systemctl status kubelet```
kubectl：二进制高唱行器具
###### 结书册群资源
组件是为了复旧k8s平台的运行，安设好的软件。
资源是如何去使用k8s的武艺的界说。比如，k8s不错使用Pod来管制业务应用，那么Pod等于k8s集群中的一类资源，集群中的通盘资源不错提供如下方式检讨：
```powershell$ kubectl api-resources```
如何结合namespace：
定名空间，集群内一个臆造的宗旨，访佛于资源池的宗旨，一个池子里不错有各式资源类型，绝大多半的资源王人必须属于某一个namespace。集群运滚动安设好之后，会默许有如下几个namespace：
```powershell$ kubectl get namespacesNAME STATUS AGEdefault Active 84mkube-node-lease Active 84mkube-public Active 84mkube-system Active 84mkubernetes-dashboard Active 71m```
- 通盘NAMESPACED的资源，在创建的时候王人需要指定namespace，若不指定，默许会在default定名空间下- 疏通namespace下的同类资源不不错重名，不同类型的资源不错重名- 不同namespace下的同类资源不错重名- 时时在表情使用的时候，咱们会创建带有业务含义的namespace来作念逻辑上的整合
###### kubectl的使用
访佛于docker，kubectl是高唱行器具，用于与APIServer交互，内置了丰富的子高唱，功能极其强劲。 https://kubernetes.io/docs/reference/kubectl/overview/
```powershell$ kubectl -h$ kubectl get -h$ kubectl create -h$ kubectl create namespace -h```
kubectl如何管制集群资源
```powershell$ kubectl get po -v=7```
#### 实践--使用k8s管制业务应用
##### 最小调动单位 Pod 录屏！！！
docker调动的是容器，在k8s集群中，最小的调动单位是Pod（豆荚）
###### 为什么引入Pod
- 与容器引擎解耦
Docker、Rkt。平台想象与引擎的具体的已毕解耦
- 多容器分享集中|存储|进度 空间， 维持的业务场景愈加机动
###### 使用yaml步地界说Pod
*myblog/one-pod/pod.yaml*
```yamlapiVersion: v1kind: Podmetadata: name: myblog namespace: demo labels: component: myblogspec: containers: - name: myblog image: 172.21.32.6:5000/myblog env: - name: MYSQL_HOST # 指定root用户的用户名 value: "127.0.0.1" - name: MYSQL_PASSWD value: "123456" ports: - containerPort: 8002 - name: mysql image: 172.21.32.6:5000/mysql:5.7-utf8 ports: - containerPort: 3306 env: - name: MYSQL_ROOT_PASSWORD value: "123456" - name: MYSQL_DATABASE value: "myblog"```
```json{ "apiVersion": "v1"， "kind": "Pod"， "metadata": { "name": "myblog"， "namespace": "demo"， "labels": { "component": "myblog" } }， "spec": { "containers": [ { "name": "myblog"， "image": "172.21.32.6:5000/myblog"， "env": [ { "name": "MYSQL_HOST"， "value": "127.0.0.1" }， { "name": "MYSQL_PASSWD"， "value": "123456" } ]， "ports": [ { "containerPort": 8002 } ] }， { "name": "mysql"， ... } ] }}```
| apiVersion | 含义 一路向西
上一篇：一路向西 前锋密斯姐炫酷登场！穿吊带衫包臀裙，挑战极限体魄展现玉足之好意思|露肩|穿搭|高跟鞋|芳华活力
下一篇：hongkongdoll real face 山西省征象台发布寒潮橙色预警|霜冻|水产业|高温天气