曾经有人问我，为什么windows这么强大了，还要学习linux，还要学习命令行。答案就在这篇内容中，我们这个互联网的世界，IT底座基本就是架构在这样的一个环境中。学习Docker，让我感受到了开源世界的强大，设计理念之巧妙，性能之强大，闪耀着智慧的光芒。centos7更新源：
cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.bakcurl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repoyum clean allyum makecacheyum repolist
1、docker容器应用三要素：
镜像、容器和仓库
2、docker容器底层技术：
Linux虚拟化技术LXC（Linux Container），包含Cgroup、Namesapce、Unionfs
3、安装并启动docker服务：
yum install wget -ycd /etc/yum.repos.d/yum install -y yum-utils device-mapper-persistent-data lvm2yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repoyum makecache fastyum install -y docker-cesystemctl start dockersystemctl enable dockerdocker --version
4、配置docker源：
vi /etc/docker/daemon.json{ "registry-mirrors": [ "https://docker.m.daocloud.io", "https://docker.imgdb.de", "https://docker-0.unsee.tech", "https://docker.hlmirror.com", "https://cjie.eu.org" ]}systemctl daemon-reloadsystemctl restart docker
5、docker常用命令
docker pull hello-worlddocker imagesdocker save hello-world > hello-world.tardocker rmi 镜像iddocker load < hello-world.tardocker run -d -p 81:80 --name=nginx1 镜像iddocker psdocker stop / docker stop -adocker start 容器iddocker inspect 容器iddocker exec -it 容器id /bin/bashdocker rm -f 容器id / docker rm -f $(docker ps -a -q)docker run -d -p 80:80 -v /root/dami:/app --name=lamp 镜像id #-v 将/root/dami文件夹挂载到容器的/app下
6、使用数据卷和绑定挂载
docker volume create datadocker volume lsdocker volume inspect datadocker pull centos:7docker run -itd --name=centos7 7e6 /bin/bash # -itd /bin/bash 防止容器启动后退出docker exec -it 56 /bin/bash
1）将宿主机空目录挂载到容器非空目录:
docker run -itd --name=centos7 -v data:/tmp 7e6 /bin/bashdocker inspect 容器ID #查看Mount挂载字段/tmp已经挂载到data卷，/tmp下的文件永久化到宿主机，删除容器不会丢失
2）宿主机非空目录挂载到容器有数据目录，容器目录会被宿主机目录下的文件替换
docker pull mysqldocker imagesdocker volume create mysqldocker volume lsdocker run --name=mysql -v mysql:/var/lib/mysql -d -p 3306:3006 -e MYSQL_ROOT_PASSWORD=1 镜像id #容器/var/lib/mysql数据同步至宿主机mysql数据卷下
如果删除容器后，mysql卷中的数据不会丢失，再次创建容器挂载卷后，会替换容器中的目录数据，从而实现数据和容器无关的能力。
mkdir /testdocker run -itd --name=centos7 -v /test:/tmp 镜像id /bin/bash #宿主机/test目录会替换掉容器中/tmp目录下的内容，在宿主机/test目录下创建的文件会自动同步到宿主机/tmp下docker inspect 容器id #Mounts的Type变为binddocker pull httpdcd /rootvi v.confdocker run --name=httpd -d -p 81:81 -v /root/v.conf:/user/local/apache2/conf/extra/http-vhosts.conf 镜像id #挂载文件
docker pull httpddocker imagesmkdir /webdocker run --name=web1 -d -p 81:80 -v /web:/usr/local/apache2/htdocs/ image-id docker run --name=web2 -d -p 82:80 -v /web:/usr/local/apache2/htdocs/ image-iddocker ps -acd /webecho "volume success" > index.htmldocker pull nginxmkdir /nginxcd /nginxtouch nginx.confdocker run --name=nginx -d -p 80:80 -v /nginx/nginx.conf:/etc/nginx/conf.d/balance.conf image-id vi /nginx/nginx.conf~upstream web { server 192.168.18.9:81; server 192.168.18.9:82;}server { listen 80; server_name localhost; location / { proxy_pass http://web; }}
7、部署Docker网络
docker network ls ，有三种网络模式，一种不使用网络，默认是bridege模式，如果要使用别的模式，可以docker run --network=选项
bridge：默认模式，类似Vmware中的NAT，容器连接到docker0虚拟网卡，通过docker0网桥以及Iptables表配置与宿主机通信
host：使用Host网络的容器与宿主机在同一个网络中，IP地址就是宿主机的IP地址，与宿主机在同一个Network Namespace
container：新创建的容器与已经存在的一个容器共享一个Network NameSpace，而不是和宿主机共享，适合两个容器频繁通信的情况
none：不对网络进行任何配置，关闭了容器的网络功能，常用于写磁盘等
在宿主机上：ip addr #查看docker0的ip地址分配yum install bridge-utils -ybrctl show #查看网桥docker0和veth pair设备docker pull alpinedocker imagesdocker run -itd --name=test1 image-id /bin/shdocker exec -it 容器id /bin/ship addrdocker run -itd --name=test2 image-id /bin/shdocker exec -it 容器id /bin/ship addr在宿主机上：iptables -t nat --list
自定义容器网络：
docker network --helpdocker network create -d bridge net #创建一个名为net的网络docker network create --subnet=172.20.0.0/16 mynetdocker network ls docker inspect netdocker run --name=mynet -itd --network=net image-id /bin/sh
构建跨主机的容器网络
hostnamectl set-hostname docker1hostnamectl set-hostname docker2ip link set ens33 promisc on #打开网卡的混杂模式在docker1上：docker network create -d macvlan --subnet 192.168.10.0/24 --gateway 192.168.10.1 -o parent=ens33 mac1 #创建了一个名为mac1的网络docker run -itd --name testmac1 --ip 192.168.10.10 --network mac1 alpinedocker network lsdocker inspect mac1在docker2上：docker network create -d macvlan --subnet 192.168.10.0/24 --gateway 192.168.10.1 -o parent=ens33 mac2docker run -itd --name testmac2 --ip 192.168.10.20 --network mac2 alpinedocker network lsdocker inspect mac2测试：在docker1上：docker exec -it 容器id /bin/shping docker2上的容器ip
8、使用Dockerfile构造镜像
1）docker commit方式
制作ssh服务镜像
docker pull centos:7docker imagesdocker run --name=centos7 -itd image-id /bin/bashdocker exec -it 容器id /bin/bash yum repolist yum install openssh-server openssh-clients -y sshd-keygen passwd root /usr/sbin/sshd -D&docker inspect 容器iddocker ps -adocker commit container_id centos_ssh:v1docker imagesdocker run --name=ssh -d -p 23:22 centos_ssh:v1 /usr/sbin/sshd -D
2）使用Dockerfile方式构建ssh镜像
docker pull centos:7mkdir sshcd sshvi Dockerfile~ FROM centos:7 RUN yum install openssh-server openssh-clients -y && sshd-keygen && echo "1"|passwd --stdin root EXPOSE 23 CMD ["/usr/sbin/sshd",'-D&']docker build -t ssh:v1 .docker run --name=sshv1 -d -p 24:22 image_id
3）使用Dockerfile方式构建web服务镜像
docker pull centos:7mkdir httpdcd httpdvi Dockerfile~ FROM centos:7 RUN yum install httpd -y #容器运行时，volume目录持久化到宿主机 VOLUME ["/var/www/html"] EXPOSE 80 CMD ["/usr/sbin/httpd","-DFOREGROUND"]docker build -t httpd:v1 .docker run --name=httpd -d -p 80:80 httpd:v1docker respect container_id #查看持久化目录
4)使用Dockerfile方式构建Apache和SSH多服务镜像
mkdir httpdsshcd httpdsshvi Dockerfile~ FROM centos:7 ENV PASS=1 RUN yum install httpd openssh-server openssh-clients -y && sshd-keygen && echo $PASS | passwd --stdin root #将当前目录下脚本run.sh添加到容器根目录下 ADD run.sh /run.sh EXPOSE 80 22 CMD ["/bin/bash","/run.sh"]vi run.sh#!/bin/bashif [ -n $PASS ];then echo $PASS | passwd --stdin rootfi/usr/sbin/httpd/usr/sbin/sshd -Ddocker build -t httpdssh:v1 .docker run --name=httpdssh -d -p 80:80 -p 23:22 -e PASS=2 image_id
5)使用Dockerfile方式构建Tomcat服务镜像
建立tomcat目录，下载JDK源程序(jdk)和Tomcat源程序（apache-tomcat)~FROM centos:7#改变工作路径WORKDIR /usr/localRUN mkdir jdkADD jdk-8u60-linux-x64.tar.gz /usr/local/jdkADD apache-tomcat-7.0.70.tar.gz /usr/local/RUN ln -s /usr/local/apache-tomcat-7.0.70 /usr/local/tomcatENV JAVA_HOME=/usr/local/jdk/jkd1.8.0_60ENV PATH=$JAVA_HOME/bin:$PATHRUN chmod u+x /usr/local/tomcat/bin/catalina.shEXPOSE 8080ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh","run"]docker build -t tomcat:v1 .docker run --name=tomcat -d -p 8080:8080 image_id
6)构建PHP web应用镜像
docker pull centos:7mkdir phpcmscd phpcmsrz 网站页面vi Dockerfile~FROM centos:7RUN yum install httpd php php-mysql php-gd -yADD 网站页面目录 /var/www/htmlRUN chmod -R 777 /var/www/htmlVOLUME /var/www/htmlEXPOSE 80CMD ["/usr/sbin/httpd","-DFOREGROUND"]docker build -t php_web:v1 .docker run --name=phpweb -d -p 80:80 php_web:v1
9、创建Registry私有仓库
docker pull registrydocker run --name=registry -d -v /myregistry:/var/lib/registry -p 5000:5000 --restart=always registry
修改/etc/docker/daemon.json：
{ "registry-mirrors": ["https://9pjo186d.mirror.aliyuncs.com"], "insecure-registries": [192.168.0.20:5000"]}systemctl daemon-reloadsystemctl restart dockerdocker tag alpine:latest 192.168.0.20:5000/alpine:v1 #修改镜像名称docker push 192.168.0.20:5000/alpine:v1 #上传镜像curl http://192.168.0.20:5000/v2/_catalog #查看已经上传的镜像
cd /myregistry/docker/registry/v2/repositories/ls下载镜像：docker rmi alpine:latest #先删除原有镜像修改/etc/docker/daemon.json文件：{ "registry-mirrors": ["https://9pjo186d.mirror.aliyuncs.com"], "insecure-registries": ["192.168.0.20:5000"]}systemctl daemon-reloadsystemctl restart dockerdocker pull 192.168.0.20:5000/alpine:v1 #镜像的名称构成是：仓库地址/仓库名称：tag标签配置Registry私有仓库认证：yum install httpd-tools -ymkdir /authhtpasswd -Bbn 123 > /auth/htpasswddocker run -d -p 5000:5000 -v /auth/:/auth/ -v /myregistry:/var/lib/registry -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" \-e "REGISTRY_AUHT_HTPASSWD_PATH=/auth/htpasswd" registry
客户端docker push提示没有权限，需要登录：
docker login 192.168.0.20:5000username:password:
登录成功后，就可以上传镜像了。
10、创建Harbor企业级私有仓库
wget https://gihub.com/goharbor/harbor/releases/download/v2.1.2/harbor-offline-installer-v2.1.2.tgzwget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo #下载扩展源yum install Docker-Compose -ytar xf harbor-offline-installer-v2.1.2.tgzcd harbormv harbor.yml.tmpl harbor.yml# 打开harbor.yml，修改hostname为服务器IP地址或域名，初始用户名密码admin/Harbor123456docker rm -f $(docker ps -a -q) #删除其他所有容器./install.sh
安装完毕后，docker ps -a可以查看到Harbor启动了9个容器，在浏览器上就可以访问harbor管理页面了
从客户端推送镜像到Harbor仓库：
修改/etc/docker/daemon.json文件，{ "registry-mirrors": ["https://9pjo186d.mirror.aliyuncs.com"], "insecure-registries": ["192.168.0.20”]}systemctl daemon-reloadsystemctl restart docker
docker login 192.168.0.20username:adminpassword:Harbor12345
docker tag nginx:1.18.1 192.168.0.20/library/nginx:1.8.1docker push 192.168.0.20/library/nginx:1.8.1docker pull 192.168.0.20/library/nginx:1.8.1
配置https安全访问Harbor私有仓库：
openssl genrsa -idea -out server.key 2048 #生成私钥server.keyopenssl req -days 36500 -x509 -sha256 -nodes -newkey rsa:2048 -keyout server.key -out server.crt #基于私钥生成证书修改Harbor配置文件harbor.yml，去掉https9-15行的注释，并添加certificate: /root/server.crt和private_key: /root/server.keydocker rm -f $(docker ps -a -q)./install.sh在Node主机上登录https方式的Harbor:mkdir -p /etc/docker/cert.d/192.168.0.20cd /etc/docker/cert.d/192.168.0.20scp root@192.168.0.20:/root/server.crt .docker login https://192.168.0.20
11、监控容器与限制资源：
容器监控主要有三方面的内容：主机的监控、镜像的监控、运行容器的监控
1）主机的监控：CPU、内存、本地镜像、容器运行情况
2）镜像的监控：镜像基本信息、与容器的对应关系、镜像构建的历史信息、镜像的总数量、ID、名称、版本、大小等
3）容器的监控：容器的基本信息(docker ps)、容器的运行状态（docker status、docker top、docker port)
docker run -d --memory=2000M --name=nginx nginx:1.8.1docker stats nginx
docker pull docker.ip/portainer/portainerdocker run -d -p 9000:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --name portainer docker.io/portainer/portainer
浏览器打开宿主机9000端口，创建用户密码即可使用
docker pull google/cadvisordocker run --volume=/:/rootfs:ro --volume=/var/run:/var/run:rw --volume=/sys:sys:ro --volume=/var/lib/docker/:/var/lib/docker:ro --volume=/dev/disk:/dev/disk:ro \--publish=80:8080 --detach=true --name=cadvisor google/cadvisor:latest
限制容器资源：
1）Cgroup，Control Group的缩写，可以限制、记录、隔离进程组所使用的物理资源，如CPU、内存、I/O等
构建stress镜像（该工具是很好的资源利用测试工具）,编写Dockerfile:
mkdir stresscd stressvi Dockerfile~FROM centos:7RUN yum install wget -yRUN wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repoRUN yum install -y stressdocker build -t stress:latest .
限制使用CPU：docker run -itd --name cpu50 --cpu-shares 50 stress stress -c 10 #运行第一个容器，10个进程，cpu限制份额50docker run -itd --name cpu100 -cpu-shares 100 stress stress -c 10 #运行第二个容器，10个进程，cpu限制份额100docker run --name=cputime -itd --cpu-period 200000 --cpu-quota 100000 stress #运行了容器，在0.2s的刷新时间内，占用CPU的时间是0.1sdocker run -itd --name cpu2 --cpuset-cpus 0-1 stress stress -c 10 #设置使用两个CPU内核（0和1）
限制使用内存：docker run -it -m 100M --memory-swap=200M progrium/stress --vm 1 --vm-bytes 150M #stress镜像，分配内存100MB，内存加交换分区一共200MB，启动一个内存工作线程，每个线程给150MB内存docker run -it -m 100M --memory-swap=200M progrium/stress --vm 2 --vm-bytes 120M #内存不足，容器运行失败
限制使用磁盘：docker run -itd --name diska --blkio-weight 800 stress #设置容器diska是容器diskb读写磁盘权重的2倍docker run -itd --name diskb --blkio-weight 400 stress #docker run --name=10m -itd --device-write-bps /dev/sda:10MB stress #设置对sda磁盘的写入速度为10MB，device-read-bps,device-write-bps,device-read-iops,device-write-iops
12、单机编排容器
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repoyum install docker-compose -ydocker-compose --version
Docker Compose通过定义模板文件来编排多个容器，默认的文件名：Docker-Compose.yml，在模板中需定义version、services、networks、volumes等，最重要的是服务。
编排nginx服务：mkdir nginxcd nginxvi Docker-Compose.yml~version: '3'services: web: image: nginx:1.8.1 ports: - 80:80docker-compose up -d #会启动一个容器，名字为nginx_web_1，其中nginx为当前目录名称，web是定义的服务，_1代表第一个服务docker-compose psdocker network ls编排mysql服务：mkdir mysqlcd mysqlvi docker-compose.yml:~version: '3'services: mysql: image: mysql:5.7 networks: - mynet ports: - 3306:3306 environment: MYSQL_ROOT_PASSWORD: 1networks: mynet: driver: bridgedocker-compose up -ddocker-compose ps #如果要关闭所有的服务，可以用docker-compose downdocker network ls编排wordpress博客应用docker pull wordpressmkdir wordpresscd wordpressvi docker-compose.yml~version: '3'services: wordpress: image: wordpress prots: - 80:80 depends_on: - mysql #先启动mysql服务 environment: WORDPRESS_DB_HOST: mysql:3306 WORDPRESS_DB_PASSWORD: root networks: - my-wordpress mysql: image: mysql:5.7 environment: MYSQL_ROOT_PASSWORD: root MYSQL_DATABASE: wordpress volumes: - mysql-data:/var/lib/mysql networks: - my-wordpressvolumes: mysql-data:networks: my-wordpress: driver: bridgedocker-compose up -ddocker-compose psdocker network lsdocker volume ls动态编排web集群服务：mkdir dedecd dedevi Dockerfile:~FROM centos:7RUN yum install http php php-mysql php-gd -yEXPOSE 80CMD ["/usr/sbin/httpd","-DFOREGROUND"]vi docker-compose.yml:~version: '3'services: lb: image: dockercloud/haproxy links: - zm ports: - 80:80 - 1936:1936 volumes: -/var/run/docker.sock:/var/run/docker.sock networks: - front zm: build: ./dede depends_on: - mysql volumes: - /root/webcluster/dede/zm:/var/www/html networks: - front - back mysql: image: mysql:5.7 networks: - back environment: MYSQL_ROOT_PASSWORD: 1 volumes: - mysql:/var/lib/mysqlvolumes: mysql:networks: front: driver:bridge back: driver:bridgedocker-compose up -dchmod -R 777 /root/webcluster/dede/zm/docker-compose up --scale zm=3 -d #启动一个数据服务，三个zm服务（web网站），一个lb（负载均衡）docker-compose ps
13、Kubernetes多机编排容器
1）安装Kunbernetes双节点环境
hostname set-hostname masterhostname set-hostname node1systemctl stop firewalld && systemctl disable firewalld #双机均执行setenforce 0 #双机均执行swapoff -a #双机均执行/etc/fstab中的swap行注释掉 #双机均执行/etc/hosts文件增加： #双机均执行192.168.0.10 master192.168.0.20 node1ssh-keygen #master执行ssh-copy-id root@node1 #master执行配置yum源： #双机均执行1)建立本地yum源local.repo[local]name=centos7basurl=file:///mntgpgcheck=02)下载阿里云的centos7基础源wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo3)建立阿里云的docker-ce源docker-ce.repo在阿里云https://developer.aliyun.com/mirror/，找到Docker的源地址，在centos7处查看配置方法yum install -y yum-utils device-mapper-persisitent-data lvm2yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo4)建立阿里云的Kubernetes源k8s.repo在阿里云镜像找到Kubernetes源配置，复制到k8s.repo中yum install iptables -y #双节点均安装modeprobe br_netfiltervi /etc/sysctl.conf~加入net.ipv4.ip_forward = 1net.bridge.bridge-nf-call-iptables = 1net.bridge.bridge-nf-call-ip6tables = 1sysctl -p #配置生效vi /etc/sysctl.d/k8s.conf~net.bridge.bridge-nf-call-ip6tables = 1net.bridge.bridge-nf-call-iptables = 1sysctl --systemyum install docker-ce -y #双节点均安装vi /etc/docker/daemon.json~{ "exec-opts": ["native.cgroupdriver=systemd"], "log-driver": "json-file", "log-opts": { "max-size": "100m" }, "storage-driver": "overlay2", "storage-opts": [ "overlay2.override_kernel_check=true" ]}systemctl daemon-reload && systemctl restart docker安装Kubernetes组件：yum install kubeadm-1.18.3 kubelet-1.18.3 -y #双节点均执行systemctl start kubelet && systemctl enable kubelet上传Kubenetes组件镜像：用rz命令，如没有，则yum install lrzsz -y安装共14个，上传完成，需要导入到本地：for i in $(ls);do docker load < ${i};done初始化Kubernetes集群：kubeadm init --kubernetes-version=v1.18.3 --pod-network-cidr=172.16.0.0/16 --apiserver-advertise-address=192.168.0.10 #master执行即可注意以上命令的输出，有详细的后续指导，尤其关注加入主机的部分命令mkdir -p $HOME/.kubesudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/configsudo chown $(id -u):$(id -g) $HOME/.kube/configkubeadm join 192.168.0.10:6443 --token ab4rn3.uuxa8fzr3y523tvc --discovery-token-ca-cert-hash sha... #保存这段信息到一个文件，用于后期新node节点加入，在node执行kubectl get nod #在master查看集群节点，状态NotReady，是因为没有安装网络上传calico.yaml文件到master节点后：kubectl apply -f calico.yaml #执行后，两个节点都是Readykubectl get cs #如果都是healthy，则安装成功yum install bash_completion -y #k8s命令的补全功能kubectl completion bash > /etc/profile.d/k8s.shbash
2）使用命令编排多机容器
（1）创建Pod服务单元，pod中包含一个默认的Pause容器，他有一个IP，一个存储卷，其他容器共享Pause容器的IP地址和存储，实现文件共享和通信
创建Pod：
kubectl run pod1 --image=nginx:1.8.1 #创建名称为pod1的单元，基于nginx:1.8.1运行了一个容器kubectl get podkubectl get pod -o wide #查看pod详细信息kubectl describe pod pod1 #查看pod更加详细信息kubectl exec -it pod1 -c pod1 /bin/bash #进入pod中的容器curl http://172.16.1.4 #在master执行，浏览pod容器的应用kubectl delete pod pod1 #删除pod
(2）创建Deployment控制器
创建控制器：
kubectl create deployment kzq --image=nginx:1.7.9kubectl get deployments.apps #查看控制器kubectl get pod #查看当前podkubectl describe deployments.apps kzq #查看控制器详细信息kubectl scale deployment --replicas=3 kzq #把pod服务单元个数增加到3个kubectl get pod -o wide #查看podmaster节点污点去除：kubectl taint node master node-role.kubernetes.io/master:NoSchedule- #去除了master污点后，节点资源不足的情况下，master也可以当node使用kubectl scale deployment --replicas=5 kzq #会调度到master和node上kubectl delete pod kzq-c769cb9c4-8pcgt #删除一个pod节点后，会自动增加节点替换被删除的podkubectl scale deployment --replicas=3 kqz #减少pod数量
(3）创建服务发现暴露应用
创建服务发现：
kubectl expose deployment kzq --port=80 #把deployment暴露出去kubectl get servicekubectl describe service kzq #能查看到后端对的Endpointskubectl exec -it kzq-c769cb9c4-9frfz /bin/bash #可以进入某个容器，修改文件内容curl kzq-service的ip地址，自动实现负载均衡，但这个地址只能在集群内访问service默认类型是ClusterIP，修改为NodePort类型，就可以实现外部访问了，命令：kubectl edit service kzqkubectl get service kzq #类型变为NodePort后，对外暴露的端口也能查看，外部分期访问任何一个节点的IP加上端口号就可以。
（4）更新与回滚服务版本
kubectl describe pod kqz-c769cb9c4-9frfz #查看Containers中的容器名称kubectl set image deployment kzq nginx=nginx:1.8.1 #更新镜像版本kubetl get pod -o wide #可以查看更新后的podcurl -I 某个pod的ip #查看更新版本号kubectl rollout history deployment kzq #查看kzq控制器的历史版本信息kubectl rollout undo deployment kzq --to-revision 1 #回退某个控制器的版本，这里是回退到历史1版本
3）使用YAML文件编排多机容器（实际工作中均使用此种方式）
（1）使用YAML文件创建pod
kubectl explain pod #编写YAML文件，该命令可以解释任何想定义的内容Kubectl explain pod.metadata #进一步查询解释
编写YAML文件定义Pod:
建立一个目录yaml，在该目录下创建一个pod.yaml文件，内容如下：
apiVersion: v1kind: Podmetadata: name: pod1 labels: app:nginxspec: containers: - name: nginx image: nginx:1.7.9 ports: - name: port1 containerPort: 80
kubectl apply -f pod.yaml #创建podkubectl get pod pod1 -o wide #查询pod信息
修改pod，只需要修改pod.yaml文件，再重新运行kubectl apply -f pod.yaml即可
kubectl delete -f pod.yaml #删除pod
（2）使用YAML文件创建Deployment控制器
kubectl explain deployment
编写YAML文件定义deployment，如下：
apiVersion: apps/v1kind: Deploymentmetadata: name: de1spec: template: metadata: labels: app:nginx spec: containers: - name: nginx image: nginx:1.7.9 ports: - name: p1 containerPort: 80 selector: matchLabels: app:nginx replicas: 3
kubectl apply -f de.yaml #创建deploymentkubectl get deployments.apps de1 #查询de1信息kubectl get pod
修改de.yaml，将replicas修改为4，
(3）使用YAML文件创建服务发现
在yaml目录创建s1.yaml，内容如下：
apiVersion: v1Kind: Servicemetadata: name: mynginxspec: selector: app:nginx ports: - name: http80 port: 80 targetPort: 80
kubectl apply -f s1.yamlkubectl describe service mynginx
集群内部已经可以访问，要外部访问，编辑s1.yaml文件，和ports对齐，添加type:NodePort，如下：
ports: - name: http80 port: 80 targetPort: 80 nodePort:30000type: nodePort
kubectl apply -f s1.yamlkubectl get services mynginx
4）使用Kubernetes部署动态Web集群
（1）搭建NFS服务
yum install nfs-utils -y #master节点安装配置nfs：mkdir /web mkdir /mysql在/web下上传一个网站damichmod -R 777 damivi /etc/exports~/web/dami 192.168.0.0/24(rw,no_root_squash)/mysql 192.168.0.0/24(rw,no_root_squash)
将以上两个目录配置给192.168.0.0/24网段上的主机，设置读写和root访问权限
systemctl start nfs #启动nfs服务showmount -e 192.168.0.10 #查看NFS共享目录
(2）部署动态Web集群
构建支持PHP程序镜像，编写Dockerfile，在/root目录下创建php目录，创建Dockerfile文件：
FROM centos:7RUN yum install httpd php php-mysql php-gd -yEXPOSE 80CMD ["/usr/sbin/httpd","-DFOREGROUND"]
在yaml目录中，创建dami.yaml文件：
APIVersion: apps/v1kind: Deploymentmetadata: name: de2spec: template: metadata: labels: app:dami spec: containers: - name: dami image: php:v1 ports: - name: p1 continerPort: 80 volumeMounts: - name: nfs1 mountPath: /var/www/html volumes: - name: nfs1 nfs: path: /web/dami server: 192.168.0.10selector: matchLabes: app:damireplicas: 3
scp Dockerfile root@node1:/root/php #将master上的Dockerfile传到Node1上
docker build -t php:v1 #在Node1上执行，生成镜像kubectl apply -f dami.yaml #在master上执行kubectl get pod -o wide #查看pod数量
创建NodePord类型的service，创建s2.yaml：
apiVersion: v1kind: Servicemetadata: name: s2spec: selector: app:dami ports: - name: http80 port: 80 targetPort: 80 nodePort: 30001 type: NodePort
kubectl apply -f s2.yamlkubectl describe service s2
（3）编写构建数据库的容器：
在yaml目录中创建mysql.yaml文件：
apiVersion: apps/v1kind: Deploymentmetadata: name: de3spec: template: metadata: labels: app:mysql spec: containers: - name: mysql image: mysql:5.7 env: - name: MYSQL_ROOT_PASSWORD value: "1" ports: - containerPort: 3306 volumeMounts: - name: nfs1 mountPath: /var/lib/mysql volumes: - name: nfs1 nfs: path: /mysql server: 192.168.0.10selector: matchLabels: app:mysql
kubectl apply -f mysql.yamlkubectl get pod -o wide
在yaml目录下，创建文件s3.yaml：
apiVersion: v1kind: Servicemetadata: name: s3spec: selectors: app:mysql ports: - name: http80 port: 3306 targetPort: 3006
kubectl apply -f s3.yamlkubectl get service s3
14、Swarm编排工具
配置三台主机：
1）master管理节点，192.168.51.101/24
2）node1工作节点，192.168.51.102/24
3）node2工作节点，192.168.51.103/24
修改主机名：hostnamectl set-honstname xxx同步时间：ntpdate ntp1.aliyun.com安装软件：master和node1，node2上均需安装docker，并配置加速器：修改启动参数：vi /lib/systemd/system/docker.service~ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix://var/run/docker.socksystemctl daemon-reloadsystemctl restart dockersystemctl status docker #如果active(running)提示，则表示成功netstat -tunlp #查看2375端口docker pull swarm #master和node均执行docker swarm init --advertise-addr 192.168.51.101 #在master节点上初始化集群，获取tokendocker swarm join --token .... 192.168.51.101:2377 #在node节点执行，加入集群docker node ls #查看集团各节点状态docker pull nginx #master和node均执行，举例docker network create -d overlay nginx_net #master节点创建网络nginx_netdocker network lsdocker service create --replicas 1 --network nginx_net --name my-test -p 9999:80 nginx #在master节点创建一个副本数为1的nginx容器docker service lsdocker service inspect --pretty my-testdocker service inspect my-test #更详细信息docker service ps #查看my-test运行在哪个节点docker service scale my-test=5 #在master节点执行，将my-test容器扩展到5个docker service ps my-testdocker service scal my-test=1 #在master节点执行，缩容至1个如果一个节点出现宕机，该节点会从swarm集群移除，宕机节点上运行的容器会被调度到其他节点，满足指定副本数量的运行systemctl stop docker #在某个Node节点执行docker node lsdocker service ps my-test #查看容器被调度情况当宕机恢复后，容器并不会自动调度回来docker volume create --name volume-test #在各主机节点创建数据卷docker volume lsdocker volume inspect volume-testcd /var/lib/docker/volumes/volume-test/_data #进入各主机节点的数据卷目录echo "This is nginx-test in master/nodex" > index.htmldocerk service create --replicas 3 --mount type=volume,src=volume-test,dst=/usr/share/nginx/html --name swarm-nginx -p 8001:80 nginx #主节点创建副本3的容器，挂载volume-testdocker service ps swarm-nginxfor i in [1..10];do curl 192.168.1.101:8001;done #验证负载均衡的效果
15、自动化部署工具Rancher
利用Rancher搭建Swarm集群(类似也可以管理kubernetes）
1）master：192.168.51.100/24
2）node1：192.168.51.102/24
3）node2：192.168.51.103/24
docker pull rancher/server:stable #master执行docker run -d --restart=unless-stopped -p 8000:8080 rancher/server:statble浏览器输入http://192.168.51.100:8000，Default->管理环境->创建环境模板（myswarm）->编辑模板，manager修改为1，设置按钮保存添加环境(swarm-demo)->选择环境模板(myswarm)->创建选择swarm-demo->添加主机-保存，复制主机注册脚本，在各个主机上运行脚本，swarm集群创建成功。
持续集成
持续集成鼓励团队开发成员经常集成其工作，甚至每天都发生多次集成。每次集成都通过自动化的构建来验证，包括自动编译，发布和测试，从而尽快发现集成错误，使团队更聚焦开发内聚的软件。
持续集成指在开发阶段对项目持续性自动化编译，测试，达到控制代码质量的效果。
16、Git+Jenkins+Maven+Docker实现WEB项目自动部署
1）上传文件apache-maven、apache-tomcat、docker-ce、jdk、jenkins.war
2）安装docker并配置镜像加速器
3）安装JDK
cd /opttar zxvf jdk-8u162-linux-x64.tar.gzmkdir /usr/local/jdkmv jdk1.8.0_162 /usr/local/jdk/jdk1.8.0_162vi /etc/profile~export JAVA_HOME=/usr/local/jdk/jdk1.8.0_162export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/export PATH=$PATH:$JAVA_HOME/binsource /etc/profilejava -version
4）安装moven
tar zxf apache-maven-3.5.4-bin.tar.gzmv apache-maven-3.5.4 /usr/local/maven3vi /etc/profile~export M2_HOME=/usr/local/maven3export PATH=$PATH:$JAVA_HOME/bin:$M2_HOME/binsource /etc/profilemvn -v
5）配置GitHub
docker pull gogs/gogs:latestdocker pull mysql:latestdocker run -d -p 3000:3000 -name mygogs gogs/gogs:latestdocker run -d -p 13306:3306 -e MYSQL_ROOT_PASSWORD=000000 --name mygogs-mysql mysql:latestdocker exec -it mygogs-mysql /bin/bashmysql -uroot -p000000>create database gogs;打开浏览器，输入192.168.51.100:3000，安装程序设置，立即安装，注册用户，登录，新增仓库名称为hbliti。yum -y install gitgit clone http://192.168.51.100:3000/hbliti/hbliti.git
6）配置Junkins
yum -y install unzipunzip apache-tomcat-8.5.43.zipcp jenkins.war /opt/apache-tomcat-8.5.43/webapps/cd /opt/apache-tomcat-8.5.43/webapps/lscd /opt/apache-tomcat-8.5.43/bin/ll satartup.shchmod +x *.sh./startup.sh浏览器：http://192.168.51.100:8080/jenkinscat /root/.jenkins/secrets/initialAdminPassword
回到浏览器，管理员，密码，继续，安装推荐的插件，创建管理员账户，配置完成。
开始使用Jenkins
系统管理->全局工具配置设置要使用到的构建工具和JDK版本，取消自动安装
系统管理->管理插件->高级->替换升级站点替换为http://mirror.esuni.jp/jenkeins/updates/update-center.json
可选插件安装Maven Integration和Deploy to container
创建、构建和发布Maven项目
创建一个新任务->构建一个Maven项目(test-maven)->源码管理，修改Git源http://192.168.51.100:3000/hbliti/hbliti.git->构建触发卡 H/1 * * * *，表示一分钟构建一次，
选择构建环境，修改build栏目信息，配置构建环境
cd /mavengit initgit add test-mavengit config --golbal usr.email "hbliti@qq.com"git config --global usr.name "hbliti"git commit -m "first hbliti commit"git remote add origin http://192.168.51.100:3000/hbliti/hbliti.gitgit push -u origin master
在gogs服务可以查看到上传的项目，在test-maven项目中，选择立即构建，发布构建后的项目：
cd .jenkins/workspace/test-maven/test-maven/targetcp test-maven-web.war /opt/apache-tomcat-8.5.43/webapps/
开源软件的伟大，就是有无数的爱好者围绕开源的核心功能，不断的完善功能插件或配套的软件，越做越丰富，越做越强大，也更具图形化的界面。
