介绍
各种软件是什么语言写的？
zabbix（监控软件）：php
ansible（批量管理主机，执行命令，无angent）：python
openstack（云计算，管理虚拟机）：python
jekins（ci/di）:自动化部署，java
salstack（批量管理主机，执行命令，有angent）：python
普罗米修斯（Prometheus,监控）：go
docker：go
k8s（kubernetes）：go
什么是虚拟化？
-如：vmware,kvm,openstack,docker,k8s(kubernetes)
-云服务器：vmware,kvm虚拟化出来的
-阿里云，腾讯云，openstack,阿里飞天，用来管理虚拟化出来的操纵系统
-docker：进程级别的隔离，装在虚拟机，云服务器上，一个云服务器上开业跑出成百上千个docker容器，成百上千的服务器上，就会有个上万的容器
-k8s：不同机器的上万个容器如何管理
-虚拟化：打破实体结构间的不可切割的障碍
什么是docker？
-go语言实现，开源出来，很多人用
-docker-ce（免费），docker-ee（收费）
-通过go语言对lxc技术的一个封装
-上手快，简单
容器与虚拟机比较
-docker不需要虚拟硬件和操作系统，轻量级，占用体积小，启动快
Docker是一个客户端-服务端（c/s）架构程序（mysql,redis都是cs架构），整套Restful API规范
Docker非常重要的概念：镜像(image)与容器（container）
-有了镜像---》镜像运行起来是容器（真正的执行单位）
镜像从哪里来？
-镜像就是一堆文件
-从远程仓库拉取
Docker架构图
安装Docker
windows安装
windows安装（不建议你装）http://get.daocloud.io/
ubuntu安装
# 0 之前安装过先卸载
sudo apt-get remove docker docker-engine docker.io containerd runc
# 1 安装必要工具
sudo apt-get update
sudo apt-get install
apt-transport-https
ca-certificates
curl
gnupg-agent
software-properties-common
# 2 安装GPG证书
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
#换成阿里云
curl -fsSL http://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
# 写入软件源信息
#官方
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs)stable"
#换成阿里云
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
# 3 更新并安装docker-ce
sudo apt-get -y install docker-ce
# 4 开启docker服务
systemctl status docker
centos安装
# 6.8安装docker，自行搜索，升级内核版本
# docker是在linux3.1以上内核中写出来的，在乌班图下开发的，docker的新特性，乌班图先看到
# 官方建议docker运行在centos7 以上的系统
#安装
0 卸载（之前有安装过先卸载）
yum remove docker docker-common docker-selinux docker-engine
rm -rf /var/lib/docker
1 更新yum
yum update
2 安装需要的软件包， yum-util
yum install -y yum-utils device-mapper-persistent-data lvm2
3 执行（向你的yum源，增加一条记录）
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4 安装
yum install docker-ce
5 验证安装（查看版本）
docker -v
# 自从分了docker-ce和docker-ee以后，以年份命名版本
Docker version 19.03.12, build 48a66213fe #（19年03月12日发布）
6 启动docker服务
systemctl start docker
7 停止docker服务，重启docker服务
systemctl stop docker
systemctl restart docker
8 开机启动
systemctl enable docker
9 查看概要信息
docker info（你可能写了一个管理docker的运维平台）
远程仓库
# 注册，登录 https://hub.docker.com/
# 你可以上传镜像（类似于github），你把你制作的镜像传上去，别人可以下载使用
# 配置加速（之前去https://hub.docker.com/），阿里云，清华，做了一个备份，配置好以后，再拉镜像会去国内地址拉取
第一步：vi /etc/docker/daemon.json
第二步：
{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}
镜像操作
1 第一个hell0-world(没有任何意义)
docker run hello-world
1 客户端连到服务端，服务端下载了hello-world镜像
2 通过镜像跑起容器来
3 容器输出了一些东西，通过服务端发送给客户端，客户端展示在窗口上了
2 查找镜像
方式一：https://hub.docker.com/ 点点点搜索（你用这种）
方式二：docker search
3 拉取镜像
docker pull hello-world 最新版本latest
docker pull hello-world:nanoserver
4 查看机器上有哪些镜像
docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
镜像名字 版本 id号 创建时间 大小
5 删除镜像
docker rmi 镜像名字/id号 #如果还有基于镜像的容器，是不允许删除的，先输出容器，再删除images，或者加f强制删除docker rmi -f 镜像名字/id号
6 练习：拉取python3.6镜像，redis镜像，mysql5.7镜像
docker pull python:3.6
docker pull redis
docker pull mysql:5.7
docker pull centos:centos7
7 镜像是什么？
镜像是一堆文件，这堆文件通过docker跑起来，就是容器，你现在就把他当成，一个操作系统跑了这个软件（centos+redis）
假设centos的镜像跑起来，容器你就当成在你的宿主机上跑了一个centos7的操作系统（虚拟机）
好比 类和对象
容器操作
1 删除容器
docker rm 容器名字/容器id
2 启动并运行容器
#通过centos:centos7镜像，创建容器名字叫mycentos,并且把它运行起来
docker run -di --name=mycentos centos:centos7 #打印出容器的id
3 查看机器上正在运行的容器
docker ps
4 查看宿主机上所有的容器（包括停止的）
docker ps -a
5 停止容器
docker stop 容器名字/id号
6 启动容器
docker start 容器名字/id号
7 容器的创建和启动（******）
-创建：docker create --name=xxx redis docker create --name=test-container centos:centos7 ps -A
-启动：docker start test-container
-容器一直运行的原因：
-它有一条前台进程，一致运行
-以后如果自己制作镜像，运行起容器，必须有个可以夯住的命令
-如果该命令结束，该容器也就结束了
-创建并启动（run）
-i：表示运行容器
-t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。
-d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）。
--name :为创建的容器命名。如果不写，会自动分配一个名字（英文人名）
-v：表示目录映射关系（前者是宿主机目录，后者是容器目录，映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。
-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
docker run -it --name=myredis redis
#注意，docker run 镜像 如果本地没有，会先pull,再run
8 进入容器的几种方式（并不是真进入）
第一种：docker exec -it 容器id /bin/bash
docker exec 容器id ls
exec真正的作用是在容器内执行命令
第二种：ssh连接（容器内部装ssh服务端）
9 退出
exit
10 文件拷贝
-从宿主机拷贝到容器内部
docker cp aaa.txt 容器id:/home
-从容器内部拷贝到宿主机
docker cp 容器id:/home/aaa.txt /home
11 目录挂载
docker run -di -name=mycentos -v /home/lqz:/home centos:centos7
# 一旦挂载，以后宿主机目录内修改，同样影响容器内部
12 端口映射
docker run -di -p 6377:6379 redis:latest
#了解： /usr/local/bin/docker-entrypoint.sh
13 查看容器详细信息
docker inspect f81
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
容器部署
# 在容器内部署mysql
# -e表示环境变量
docker run -di --name=mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
# 官方提供的
docker run --name some-mysql -v /my/own/datadir:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
# 在容器内部署redis
docker run -di -p 6377:6379 redis:latest
# 在容器内部署nginx
docker run -di --name=mynginx -p 8080:80 nginx
部署应用映射外部目录
#部署redis,把配置文件和数据目录映射出来
#操作步骤
-1 mkdir -p /reids /redis/conf /redis/data
-2 vim /redis/conf/redis.conf
# 配置文件
bind 0.0.0.0
daemonize NO
protected-mode no
requirepass 123456
-3 创建并运行容器
docker run -p 6378:6379 --name=redis_6379 -v /redis/conf/redis.conf:/etc/redis/redis.conf -v /redis/data:/data -di redis redis-server /etc/redis/redis.conf
-4 本地window机器上远程连接到了docker里的redis
-5 cmd窗口下
redis-cli -h 101.133.225.166 -p 6378
-6 认证
auth 123456
-7 写入数据
set name lqz
-8 保存数据
save或者是bgsave（后台保存）
-9 在宿主机的/redis/data路径下就能看到一个文件
-10 不管多少次重启redis容器，数据都还在
-11 原来的redis容器没了，按照第三步再启动一遍，数据都还在
迁移与备份
其他操作
#删除所有容器
docker rm `docker ps -a -q`
#删除所有镜像
docker rmi `docker images -q`
#查看容器运行日志
docker logs 容器id
#操作步骤
1 启动一个python容器
docker run -di --name=python3 python:3.6
2 进入容器装软件
docker exec -it 71c /bin/bash
mkdir /project
pip install django==2.0.7 -i https://pypi.douban.com/simple/
exit
3 把项目拷贝进容器内部
docker cp /home python3:/project
4 把容器做成镜像
docker commit python3 mydjango
5 基于自己做的镜像运行容器
docker run -id --name=mydjango -p 8088:8088 mydjango python3 /project/test/manage.py runserver 0.0.0.0:8088 #使用python manage.py runserver 0.0.0.0:8088启动
镜像打包成压缩包
docker save -o test.tar test
镜像压缩包恢复为容器
docker load -i test.tar
dockerfile（很重要）
1 dockerfile是什么
一个文件，里面一堆指令，通过这个文件可以生成镜像
2 dockerfile指令
命令 作用
FROM image_name:tag 定义了使用哪个基础镜像启动构建流程
MAINTAINER user_name 声明镜像的创建者
ENV key value 设置环境变量 (可以写多条)
RUN command 是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file 将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file 和ADD相似，但是如果有压缩文件并不能解压
WORKDIR path_dir 设置工作目录
3 写一个dockerfile（文件名字必须交dockerfile）,django项目路径下创建dockerfile
vim dockerfile
FROM python:3.6
MAINTAINER joab
EXPOSE 8080
ADD ./requirement.txt /home/
RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/
RUN pip install uwsgi -i https://pypi.douban.com/simple/
VOLUME ["/home"]
WORKDIR /home/django_test
CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"]
4 通过dockerfile构建出镜像
docker build -t='django_2.0.7' .
5 查看镜像
docker images
6 启动容器
docker run -di --name=mydjango2 -v /home/django_test/:/home/django_test/ -p 8080:8080 django_2.0.7
7 就可以访问了
http://linqiaobao.xyz:8080/nb/
8 配置nginx转发，负载均衡
# 创建文件件
mkdir -p /opt/nginx/conf /opt/nginx/html /opt/nginx/logs
# 新建配置文件
vim /opt/nginx/conf/nginx.conf
# 写入
worker_processes 1;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
upstream node {
server 39.97.209.187:8080;
server 39.97.209.187:8081;
server 39.97.209.187:8082;
}
server {
listen 80;
server_name localhost;
location / {
#proxy_pass http://101.133.225.166:8080;
#负载均衡配置
proxy_pass http://node;
}
}
}
# 多启动几个docker容器，如果其中的一两个挂掉也不影响使用，启动命令后加 /bin/bash/ 夯住
docker run -di --name=mydjango3 -v /home/django_test/:/home/django_test/ -p 8081:8080 django_2.0.7
docker run -di --name=mydjango4 -v /home/django_test/:/home/django_test/ -p 8082:8080 django_2.0.7
# docker中运行nginx，监听8888端口，nginx随机转发到8080，8081，8082端口，达到负载均衡
docker run --name nginx -id -p 8888:80 -v /opt/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /opt/nginx/html:/etc/nginx/html -v /opt/nginx/logs:/var/log/nginx nginx
# 假设8081的容器挂了，8080的容器挂了，正常提供服务
# 后续再把挂掉的docker容器启动起来即可
docker start 容器id/容器名称
私有仓库
准备
1 把自己的镜像传到docker hub上
-docker login 输入用户名密码
-给你要上传的image打个标签docker tag 5452fa6715c0 liuqingzheng/django1.11.9:v1
-docker images
-docker push liuqingzheng/django1.11.9:v1
步骤
1 拉取私有仓库镜像
docker pull registry
2 启动容器
docker run -di --name=registry -p 5000:5000 registry
3 打开浏览器 输入地址http://101.133.225.166:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
4 配置
修改daemon.json
vi /etc/docker/daemon.json
添加以下内容，保存退出。
{"insecure-registries":["101.133.225.166:5000"]}
此步用于让 docker信任私有仓库地址
5 重启docker 服务
systemctl restart docker
6 重启容器
docker start registry
7 打标签
docker tag 5452fa6715c0 101.133.225.166:5000/django1.11.11
8 上传到私有仓库
docker push 101.133.225.166:5000/django1.11.11
9 从私有仓库拉取镜像
docker pull 101.133.225.166:5000/django1.11.11
docker-compose
1 Docker Compose是一个能一次性定义和管理多个Docker容器的工具（单机情况下的），多级管理容器的有k8s（谷歌出的）
2 通过yml文件定义多个容器
3 默认名字docker-compose.yml
4 三个概念，Service Networks ，Volumes
一个service代表一个container，这个container可以从docker hub的image来创建，或者从本地dockerfile build的image来创建
5 version：有1，2，3版本，目前都用"3"
6 安装命令
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
7 验证安装成功
docker-compose -v
docker-compose命令
# 启动管理容器
docker-compose up # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d # 后台执行，一般我们看日志输出，不用这个
docker-compose stop # 停止，不会删除容器和镜像
docker-compose down # 停止，并删除关联的容器
docker-compose start # 启动yml文件管理的容器
docker-compose ps # 正在运行的容器
docker-compose images # docker-compose管理的容器
docker-compose exec yml文件中写的service /bin/bash # 进入到容器内
部署多应用
# 部署flask redis
1 创建Dockerfile
vim Dockerfile
FROM python:3.6
COPY . /app
WORKDIR /app
RUN pip install flask redis
EXPOSE 5000
CMD [ "python", "app.py" ]
2 创建docker-compose文件
vim docker-compose.yml
version: "3"
services:
redis:
image: redis
web:
build:
context: .
dockerfile: Dockerfile
ports:
- 8086:5000
environment:
REDIS_HOST: redis
3 创建app.py
vim app.py
from flask import Flask
from redis import Redis
import os
import socket
app = Flask(__name__)
redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
@app.route('/')
def hello():
redis.incr('hits')
return '你好! 查看 %s 次， hostname 是 %s.
' % (redis.get('hits'),socket.gethostname())
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=True)
4 启动--运行
docker-compose up
#5 水平扩展wed成3个
#vim app.py
from flask import Flask
from redis import Redis
import os
import socket
app = Flask(__name__)
redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
@app.route('/')
def hello():
redis.incr('hits')
return '你好! 查看 %s 次， hostname 是 %s.
' % (redis.get('hits'),socket.gethostname())
if __name__ == "__main__":
app.run(host="0.0.0.0", port=80, debug=True)
#vim docker-compose.yml
version: "3"
services:
redis:
image: redis
web:
build:
context: .
dockerfile: Dockerfile
environment:
REDIS_HOST: redis
lb:
image: dockercloud/haproxy
links:
- web
ports:
- 8080:80
volumes:
- /var/run/docker.sock:/var/run/docker.sock
# 把web扩展为3个从浏览器查看
docker-compose up --scale web=3 -d
# 减掉为1个
docker-compose up --scale web=1 -d
docker-compose.yml如何写
version: '3'
services:
wordpress:
image: wordpress
ports:
- 8080:80
environment:
WORDPRESS_DB_HOST: mysql
WORDPRESS_DB_PASSWORD: root
volumes:
- mysql-data:/var/lib/mysql
使用Docker Compose部署一个wordpress
# 第一步：docker-compose.yml
version: '3'
services:
wordpress:
image: wordpress
ports:
- 8080:80
depends_on:
- mysql
environment:
WORDPRESS_DB_HOST: mysql
WORDPRESS_DB_PASSWORD: root
networks:
- my-bridge
mysql:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_DATABASE: wordpress
volumes:
- mysql-data:/var/lib/mysql
networks:
- my-bridge
volumes:
mysql-data:
networks:
my-bridge:
driver: bridge
# 第二步：docker-compose up
环境变量
容器启动的时候-e设置进去，项目内os.environ.get('密码')，隐藏密码
多个容器间直接通信方式
1 端口映射到宿主机，直接访问宿主机
2 通过ip地址访问
3 run的时候指定 --link 容器
docker run -di --name=centos1 centos:centos7
docker run -di --name=centos2 --link centos1 centos:centos7
进入到centos2中 ping centos1 可以ping同
# 跨主机的容器通信
-端口映射