docker
概念：
- image：镜像，用于启动一个容器
- container：容器
- network：网络
- volumes：卷，用来持久存储
- plugin：插件
什么是docker？
- docker就是用来管理容器的工具
什么是容器？
- 容器就是一个独立的程序运行环境
docker用在什么场景？
- 提升开发效率
- 简化开发难度
- 实现服务隔离
- 实现快速部署
版本：
- CE：社区版
- EE：商业版本
系统条件
- 64位的CPU
- 内核版本3.10及以上
- 内核支持cggroups 和 namespace
安装docker
- 第一步：上传docker的rpm包到Linux
- 第二步：进行安装
[root@master ~]# yum localinstall docker-ce-18.06.3.ce-3.el7.x86_64.rpm
创建docker配置文件
[root@master ~]# mkdir /etc/docker
[root@master ~]# vim /etc/docker/daemon.json
{
"registry-mirrors": ["https://mzxx8xy8.mirror.aliyuncs.com"]
}
启动docker
[root@master ~]# systemctl start docker
[root@master ~]# docker info
镜像：
- 其实就是一个模板
- 通过镜像可以快速启动一个服务
- 比如，通过nginx镜像，就可以快速启动一个nginx服务
使用docker
-
拉取镜像
-
检查镜像
-
启动容器
简单使用docker
1）拉取nginx镜像文件
[root@master ~]# docker search nginx
[root@master ~]# docker pull nginx
2）拉取centos镜像文件
3）拉取busybox镜像
[root@master ~]# docker pull busybox
3）查看镜像
[root@master ~]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 6678c7c2e56c 3 weeks ago 127MB
启动容器的命令格式：
- docker run [OPTIONS] IMAGE [COMMAND] [ARG…]
启动busybox容器
[root@master ~]# docker run --name mybox1 -it busybox
- -it：进入容器
在容器中，启动一个web服务
# mkdir /data/html
# echo "test page">/data/html/index.html
# httpd -f -h /data/html
在宿主机中执行ps，查看进容器
[root@master ~]# docker ps
- docker ps 仅仅可以查看正在运行的容器，已经停止的容器看不到
- docker ps -a可以查看全部的容器
- 一旦退出容器，容器会变成停止状态
查看容器的ip信息
[root@master ~]# docker inspect mybox | grep "Address"
通过ip访问容器的apache测试页
[root@master ~]# curl x.x.x.x
作业：
1) 准备一台Centos7的服务器，检测网络正常
[root@master ~]# ping www.qq.com
2) 检查服务器docker运行是否正常，如没有请安装
安装docker
- 上传docker安装包
- yum localinstall进行安装
- 编写docker配置文件
启动docker
[root@master ~]# systemctl start docker
[root@master ~]# docker info
3) 请检查本机是否有centos镜像，如没有请下载centos镜像
[root@master ~]# docker image ls
[root@master ~]# docker pull centos:7
4) 请以centos镜像为基础镜像，创建Nginx镜像
第一步：启动一个nginx容器，让这个容器工作在后台
[root@master ~]# docker run --rm --name demo1 -d centos:7 /usr/sbin/init
[root@master ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a3a327f88ee3 centos:7 "/usr/sbin/init" 14 seconds ago Up 13 seconds demo1
第二步：进入容器
[root@master ~]# docker exec -it demo1 /bin/bash
[root@a3a327f88ee3 /]#
第三步：在容器中编译安装nginx
[root@a3a327f88ee3 /]# yum install make gcc gcc-c++ pcre-devel ncurses-devel wget zlib-devel -y
[root@a3a327f88ee3 /]# wget http://nginx.org/download/nginx-1.16.1.tar.gz
[root@a3a327f88ee3 /]# tar xvf nginx-1.16.1.tar.gz
[root@a3a327f88ee3 /]# cd nginx-1.16.1
[root@a3a327f88ee3 nginx-1.16.1]# ./configure --prefix=/usr/local/nginx && make && make install
第四步：在容器中修改nginx配置文件，让nginx工作在前台
[root@a3a327f88ee3 ~]# vi /usr/local/nginx/conf/nginx.conf
添加一行
daemon off;
第五步：退出容器，在宿主机上将demo1这个容器做成镜像
[root@master ~]# docker commit demo1 nginx
6) 请查看本地镜像列表，查看镜像创建是否成功
[root@master ~]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 82c8be6ecd2e 5 seconds ago 411MB
- 请基于new-nginx:1.0镜像运行一个容器，容器名为wg-nginx，并且将本机的8000端口映射到容器的80端口（10.
第一步：修改镜像名称
[root@master ~]# docker tag nginx:latest new-nginx:1.0
[root@master ~]# docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE
new-nginx 1.0 82c8be6ecd2e 3 minutes ago 411MB
nginx latest 82c8be6ecd2e 3 minutes ago 411MB
第二步：启动容器
- 这个容器需要进行端口转发，就是将访问宿主机的8000转发到容器的80端口
- 这个容器需要运行的程序是nginx，启动nginx的命令：/usr/local/nginx/sbin/nginx
[root@master ~]# docker run --name wg-nginx -d --rm -p 8000:80 new-nginx:1.0 /usr/local/nginx/sbin/nginx
**8) wg-nginx容器运行成功
[root@master ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3e0a3d93414f new-nginx:1.0 "/usr/local/nginx/sb…" 7 seconds ago Up 6 seconds 0.0.0.0:8000->80/tcp wg-nginx
9) 成功使用浏览器访问we-nginx容器的测试页面
- 用浏览器访问自己linux主机的ip：http://192.168.0.63:8000/
案例
案例1【11】：nsible-playbook电商项目实战:
1） 配置一台远程主机并查看连接情况
以下命令必须全部写在playbook中，否则无效
2） 设置nginx版本名称为变量并在后文playbook中使用
3） 使用模块安装apache、php及所需依赖
4） 使用模块分发apache整合php配置文件
5） 使用模块启动apache
6） 使用模块安装mysql等环境
7） 使用模块启动mysql
8） 使用模块为wordpress创建数据库并授权
9） 使用模块关闭防火墙
10） 使用模块设置触发为，关闭防火墙成功后重启apache
以上完成ansible-playbook的编写
11） 使用ansible-playbook命令检查剧本的准确性并执行
12） 使用浏览器访问并成功配置博客
案例2【11】：docker实战–27日作业
1）配置docker环境并安装
第一步：解压docker安装二进制包，生成docker的可执行程序
[root@master ~]# tar xf docker-18.09.6.tgz
[root@master ~]# cp -rvf docker/* /bin/
第二步：生成docker的配置文件
[root@master ~]# mkdir /etc/docker
[root@master ~]# mv daemon.json /etc/docker/
第三步：将docker的服务管理脚本放到指定位置
[root@master ~]# mv docker.service /usr/lib/systemd/system
启动docker
[root@master docker]# systemctl daemon-reload
[root@master docker]# systemctl start docker
2）设置docker镜像加速
[root@master ~]# vim /etc/docker/daemon.json
{
"registry-mirrors": ["https://registry.docker-cn.com"]
}
[root@master ~]# systemctl daemon-reload
[root@master ~]# systemctl restart docker
[root@master ~]# docker info
3）使用命令搜索所有centos镜像
[root@master ~]# docker search centos
4）拉取centos镜像并使用命令查看镜像
[root@master ~]# docker pull centos
[root@master ~]# docker image ls
5）以守护进程方式运行基于centos的镜像并命名为centos1
[root@master ~]# docker run --name centos1 --rm -d centos:7 init
[root@master ~]# docker ps
6）以交互方式运行基于busybox镜像的容器并命名为busybox1
[root@master ~]# docker run --name busybox1 -it --rm busybox sh
7）使用命令查看所有容器
[root@master ~]# docker ps -a
8）使用命令查看busybox1的元数据
[root@master ~]# docker container inspect busybox1
9）使用命令停止所有容器并删除
[root@master ~]# docker rm -f $(docker ps -a -q)
10）使用命令删除所有镜像
[root@master ~]# docker image prune -a -f
案例3
1）安装ansible并配置远程主机免密连接
2）(编写lnmp.yml，以下所有操作必须写在playbook中)，使用ansible模块分发源码包、安装包
3）使用ansible模块安装nginx依赖环境
4）编译安装nginx
5）推送配置文件并启动nginx
6）安装mysql和php相关服务
7）配置nginx和php整合
8）重启nginx并配置php测试页面为hello world
9）成功运行playbook
案例4
1） 配置安装docker
2） 设置镜像加速
3） 拉取centos镜像
4） 使用命令查看当前镜像
5） 交互方式运行基于centos镜像的容器，命名为centos1
6） 在容器内安装网络工具并查询网络
7） 退出容器并使用命令查看当前所有容器信息
8） 删除容器centos1
9） 删除centos镜像
docker使用
- 管理镜像
- 管理容器
- 管理存储
- 管理网络
管理镜像：
- build ：基于dockerfile制作镜像
- inspect：显示镜像的详细信息
- load：从压缩包中导入镜像
- save：将当前的某个镜像导出制作成压缩包
- ls：查看当前本地有哪些镜像
- pull：从镜像仓库拉取镜像到本地
- push：将一个本地镜像推送到镜像仓库
- rm：删除镜像
- tag ：给镜像打标签
- prune：删除所有未使用的镜像
关于镜像仓库
- 专门用来存储docker镜像的服务器，称之为镜像仓库
- 网络上有很多镜像仓库
操作1：查看本地有哪些镜像
[root@master ~]# docker image ls
[root@master ~]# docker images
操作2：搜索镜像【比如搜索全部的nginx镜像】
[root@master ~]# docker search nginx
操作3：拉取镜像【拉取nginx:1.17.7-alpine】
[root@master ~]# docker image pull nginx:1.17.7-alpine
操作4：向docker仓库推送镜像
[root@master ~]# docker image push xxxxx
操作5：删除镜像
[root@master ~]# docker image rm -f nginx:2.0
[root@master ~]# docker rmi -f 470
操作6：查看镜像的详细信息
[root@master ~]# docker image inspect 82c
操作7：导出镜像操作【将nginx1.17.7-alpine导出】
[root@master ~]# docker image save 36189e6707f4>ngx.tar.gz
操作8：导入镜像【删除原有镜像，然后导入镜像】
[root@master ~]# docker load -i ngx.tar.gz
操作9：给镜像打标签【名称设置为nginx，tag设置为1.17.7-alpine】
[root@master ~]# docker image tag 361 nginx:1.17.7-alpine
操作10：将一个正在运行的容器制作成镜像
例子：先安装一个centos容器，在这容器中安装nginx，修改配置文件，然后将这个做了修改的容器制作成镜像
[root@master ~]# docker commit mycon1 nginx-temp:v0.1
容器的管理
docker container的子命令
- cp：在宿主机和容器中互相发送
- run：启动一个容器
- inspect：显示容器的详细信息
- pause：挂起容器
- unpause：将挂起的容器继续运行
- stop：关闭容器
- start：将关闭的容器重新运行
- prune：删除所有已经停止的容器
- rm：删除指定的容器
- rename：修改容器的名称
- stats：动态显示容器的资源使用情况
- ls：显示容器
- logs：查看容器中的日志信息
- exec：登录一个指定的容器
docker的子命令
- kill：杀死容器
- ps：查看容器
- rm：删除容器
- run：运行容器
操作1：运行一个nginx容器
格式：docker run [选项] 镜像名 [命令]
选项：
- -d：让容器工作在后台
- -i：以交互防护启动容器
- -t：给用户绑定一个终端
- –name：给容器设置名称
- –rm：容器停止后自动删除容器
例子：启动一个nginx，让nginx工作在前台
[root@master ~]# docker container run --name my1 nginx:1.17.9
例子：启动一个nginx，让nginx工作在前台，并且给用户绑定一个交互窗口
[root@master ~]# docker run --name my2 -it nginx:1.17.9 /bin/bash
例子：启动一个nginx，让nginx工作在后台
[root@master ~]# docker container run --name my1 -d nginx:1.17.9
操作2：登录已经启动的容器
例子：启动一个nginx容器工作在后台，然后登录这个容器
[root@master ~]# docker run --name mycentos2 --rm -d centos:7 /usr/sbin/init
[root@master ~]# docker exec -it mycentos2 /bin/bash
操作3：查看容器【已经停止的容器/正在运行的容器】
格式：docker ps [选项]
选项：
- -a：显示全部的容器，包括已经的容器
- -q：仅仅显示容器的ID
案例1 ：显示所有容器的id
[root@master ~]# docker ps -q -a
案例2：仅仅显示正在运行的容器的ID
[root@master ~]# docker ps -q
c820c3ca2a1a
fe789a579425
eba7ee871cd2
b71e6fbad30b
操作3：杀死容器
案例：杀死myos2这个容器
[root@master ~]# docker kill myos2
案例：杀死全部正在运行的容器
[root@master ~]# docker kill $(docker ps -q)
操作4：删除容器【正在运行的容器/已经停止的容器】
案例：删除已经停止的容器myos2
[root@master ~]# docker rm myos2
案例：删除正在运行的容器myos3
[root@master ~]# docker rm -f myos3
案例：删除全部的容器，包括停止和运行的
[root@master ~]# docker rm -f $(docker ps -a -q)
docker网络
[root@master ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
964b5dd9df18 bridge bridge local
2a6ad00f07cc host host local
319913a95126 none null local
- bridge：桥接网络，基于docker0实现
- none：无网络，外部用户无法访问
- host：让容器和宿主机使用相同的地址
案例：创建一个无网络模式的容器
[root@master ~]# docker run --name mybx2 -it --rm \
> --network none --hostname mybx2 \
> --dns 8.8.8.8 \
> --dns-search baidu.com \
> --add-host www.qq.com:1.1.1.1 \
> busybox
/ # ifconfig
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
/ # hostname
mybx2
/ # cat /etc/resolv.conf
search linux.io
nameserver 8.8.8.8
暴露容器端口到网络
- 不做作暴露：从docker主机外部无法访问容器，仅仅可以docker主机上访问
- 暴露到特定端口：将容器的端口映射到docker主机的一个指定端口，可以完成从外部访问容器
- 暴露到随机端口：将容器的端口映射到docker主机的一个随机端口，可以完成从外部访问容器
不做作暴露
[root@master ~]# docker run --name myngx1 -d --rm nginx——+
[root@master ~]# docker inspect myngx1 | grep IPAddress
"SecondaryIPAddresses": null,
"IPAddress": "172.17.0.3",
"IPAddress": "172.17.0.3",
[root@master ~]# curl 172.17.0.3
- 此时，在外部通过浏览器无法访问web
暴露到特定端口
[root@master ~]# docker run --name myngx2 -p 8903:80 -d --rm nginx
- 外部用户访问的时候，访问的是宿主机的8903端口
暴露到随机端口
[root@master ~]# docker run --name myngx3 -p 80 -d --rm nginx
[root@master ~]# docker ps
通过ps可以看到将docker的端口暴露到那个宿主机端口
- 此时外部用户通过这个随机端口可以访问容器
联盟式网络
需要 创建两个容器，第二个容器使用第一个容器的地址
[root@master ~]# docker run --name c1 --rm -it --network centos:7 /bin/bash
[root@master ~]# docker run --name c2 --rm -it --network container:c1 centos:7 /bin/bash
修改docke容器的网络
- 默认情况下，所有容器的ip都是由docker0分配的地址
- 修改docker0的地址，就可以实现修改创建容器的网段
案例：修改docker配置文件，默认用10.0.0作为容器IP
[root@master ~]# cat /etc/docker/daemon.json
{
"registry-mirrors": ["https://mzxx8xy8.mirror.aliyuncs.com"],
"bip": "10.0.0.1/8",
"default-gateway": "10.0.0.100",
"dns": ["8.8.8.8"]
}
[root@master ~]# systemctl daemon-reload
[root@master ~]# systemctl restart docker
docker重点知识：
- 如何做端口映射：-p 宿主机端口:容器端口
- 如何指定容器的网络类型：–network host|bridge
- 链模式网络如何使用：–network contariner:容器名
docker 存储-volume
-
启动容器时候，会挂在镜像
-
在容器中执行写入操作，会对镜像进行复制【写时复制】，然后在复制的镜像中进行存储
-
关闭容器的时候，会卸载原有镜像，而且复制的镜像会被删除
-
因此，默认情况下，关闭容器后，容器中全部数据都会被删除
docker volume是用于解决docker容器数据的持久存储问题
docker volume两种类型
- docker mount volume：
- docker managed volume：docker自动将一个宿主机目录挂载到容器指定目录
docker使用volume的方法1：-v 容器的目录
案例1：将宿主机目录挂载到容器的/data/html目录下
[root@master ~]# docker run --name centos1 -it --rm -v /data/html centos:7 /bin/bash
- 默认去宿主机/var/lib/docker/volumes/6xxxxx/_data挂载到容器的/data/html下
docker使用volume的方法2：-v 宿主机上的目录:容器上的目录
案例2：将宿主机的/www挂载到容得/data/html目录下
[root@master ~]# docker run --name centos2 -it --rm \
> -v /www:/data/html \
> centos:7 /bin/bash
案例3：先创建一个容器，然后再创建一个容器，要求两个容器的挂载是使用相同的宿主机目录；而且两个容器的ip相同
[root@master ~]# docker run --name centos1 -it --rm -v /www:/data/html centos:7 /bin/bash
[root@master ~]# docker run --name centos2 --rm -it --volumes-from centos1 --network container:centos1 centos:7 /bin/bash
dockerfile
1. 什么是dockerfile
背景
- 基于centos做个镜像，镜像需要安装nginx、需要准备配置文件、需要准备测试页面…
- 而且需要经常做镜像
- 镜像需要分为很多版本：
dockerfile就是一个脚本文件，通过dockerfile文件，可以自动、按需制作镜像
制作镜像的方式：
1）commit：将一个现有容器制作成镜像
- 拉取centos镜像 -> centos容器 -> 安装程序 -> commit -> 将容器和容器中的程序打包制作成镜像
2）save：将一个本地镜像导出成一个tar文件，这个tar文件在其他主机导入以后，就行镜像了
3）dockerfile
dockerfile注意事项
1）Dockerfile文件名D大写
2）#表示注释
3）文件的第一行必须FROM指令
4）dockerfile中的指令通常是写成大写字母，但是大小写不敏感
2 dockerfile指令
1）FROM：指定基础镜像
- 基础镜像可以在本地，也可以在网络
- 优先找本地的镜像
2）LABEL：设置镜像的元数据
3）COPY：将宿主机上的文件复制到目标镜像文件中
案例：基于centos7做个镜像，在这个镜像中准备一个html文件
第一步：首先创建一个Dockerfile文件
[root@master ~]# cat Dockerfile
FROM centos:7
LABEL [email protected] \
date=20200330
COPY index.html /data/html/
第二步：准备要放入容器的index.html
- 宿主机上，用于copy的文件，必须在Dockerfile同级目录或子目录下，不能在Dockerfile父目录
[root@master ~]# echo "test page">index.html
[root@master ~]# ls
Dockerfile index.html
第三步：制作镜像
[root@master ~]# docker build -t img1 .
[root@master ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
img1 latest 4dd700f2e276 4 minutes ago 203 MB
第四步：基于新镜像启动容器
- 在这个容器中，可以看到在制作镜像时候放进去的文件
4）ADD：也是将一个文件放到镜像中，ADD支持url
- ADD的的文件如果是本地压缩包，则会解压，然后放到容器中
- ADD的文件是一个网络文件压缩包，则是放到镜像中，但是不解压
FROM centos:7
LABEL [email protected] \
date=20200330
COPY index.html /data/html/
ADD nginx-1.17.9.tar.gz /tmp/
5）WORKDIR：类似执行cd命令
6）volume：用来指定挂载点目录
7）EXPOSE：暴露端口让用户可以访问
8）RUN：指定要执行的命令
9）CMD：指定docker运行之后，默认运行的程序，也就是ID为1的程序
- CMD 命令
- CMD [“命令”，“参数”, “参数”…] <<<<<推荐
- CMD [“参数”, “参数”…]
案例：启动容器自动运行nginx为主进程
FROM centos:7
RUN yum install gcc gcc-c++ make pcre-devel zlib-devel ncurses-devel -y
ADD http://nginx.org/download/nginx-1.16.1.tar.gz /tmp/
RUN cd /tmp && tar xf nginx-1.16.1.tar.gz
WORKDIR /tmp/nginx-1.16.1
RUN ./configure --prefix=/usr/local/nginx
RUN make && make install
RUN echo 'daemon off;'>>/usr/local/nginx/conf/nginx.conf
COPY index.html /usr/local/nginx/html/
CMD ["/bin/sh", "-c", "/usr/local/nginx/sbin/nginx"]
- 定义在CMD中的命令，在启动容器的时候，可以进行命令替换
10）ENTRYPOINT：设置容器运行起来以后要执行的命令，而且这个命令是不可以被替换，仅仅可以在这个命令后追加
FROM centos:7
RUN yum install gcc gcc-c++ make pcre-devel zlib-devel ncurses-devel -y
ADD http://nginx.org/download/nginx-1.16.1.tar.gz /tmp/
RUN cd /tmp && tar xf nginx-1.16.1.tar.gz
WORKDIR /tmp/nginx-1.16.1
RUN ./configure --prefix=/usr/local/nginx
RUN make && make install
RUN echo 'daemon off;'>>/usr/local/nginx/conf/nginx.conf
COPY index.html /usr/local/nginx/html/
CMD ["/usr/local/nginx/sbin/nginx"]
ENTRYPOINT ["/bin/sh","-c"]
11）ENV：设置变量
ENV NGX_VER="1.16.1" \
NGX_ROOT="/usr/local/nginx/"
docker容器的主进程
- 容器运行起来以后，ID为1的进程
- 主进程必须工作在前台
- 主进程一旦结束，docker容器自动结束
作业：
1 创建两个容器，让两个容器使用相同的网络地
2 创建一个nginx 容器，将nginx的80端口映射到宿主机的8442端口
3 创建一个容nginx容器，要求用户宿主机的/www目录来作为nginx网站根目录
4 编写dockerfile，制作镜像，要求如下：
1）基于centos7做镜像
2）将nginx的安装包放入镜像的/tmp下
3）准备一个nginx的配置文件，放到/etc/nginx下
4）暴露两个端口80 443
友情提示4：
# vim Dockerfile
FROM centos:7
ADD http://nginx.org/download/nginx-1.17.9.tar.gz /tmp
COPY nginx.conf /etc/nginx/
EXPOSE 80/tcp 443/tcp
构建镜像
# docker build -t img6 .
docker compose
容器编排：启动的集群包含多个服务，而且多个服务之间存在关联关系；而且多个服务启动存在先后顺序
安装docker compose
curl -L "https://github.com/docker/compose/releases/download/1.25.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
容器编排
- 通过执行一个文件来实现以此启动多个容器，多个容器之间存在依赖关系，而且多个容器的启动必须遵循特定的次序
- 实现容器编排的工具：compose，k8s
离线安装：
1：上传包
2：赋权 chmod +x docker-compose
3：移动到/bin mv docker-compose /bin
验证：
docker-compose --version
案例：通过docker compose启动两个容器，nginx，redis
[root@master ~]# vim docker-compose.yml 编写yaml文件
version: '3'
services:
web:
image: nginx:1.17.9
ports:
- 85:80
links:
- sql
sql:
image: redis:latest
[root@master ~]# docker-compose up -d 启动定义在yaml文件中的容器
[root@master ~]# docker-compose ps 查看通过yaml文件启动的容器状态
Name Command State Ports
------------------------------------------------------------------------
root_sql_1 docker-entrypoint.sh redis ... Up 6379/tcp
root_web_1 nginx -g daemon off; Up 0.0.0.0:85->80/tcp
[root@master ~]# docker-compose down 关闭通过yaml文件启动的容器
Stopping root_web_1 ... done
Stopping root_sql_1 ... done
Removing root_web_1 ... done
Removing root_sql_1 ... done
案例：通过docker-compose实现一键部署nginx+php
第一步：创建目录，用来作为volume的数据和配置文件目录
[root@master ~]# mkdir /data/nginx/{html,conf} -pv
第二步：准备nginx的配置文件
[root@master ~]# ls /data/nginx/conf/
此配置文件指定了网站根目录是/www/html
[root@master ~]# cat /data/nginx/conf/nginx.conf | grep “/www/html”
root /www/html;
第三步：编写docker-compose文件
[root@master ~]# vim docker-compose.yml
version: '3'
services:
web:
image: nginx:1.17.9
restart: always
container_name: myweb
ports:
- 85:80
volumes:
- "/data/nginx/www:/www/html"
- "/data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf"
第四步：执行yaml文件，创建nginx容器
[root@master ~]# docker-compose up -d
查看是否为up状态
[root@master ~]# docker-compose ps
Name Command State Ports
---------------------------------------------------------
myweb nginx -g daemon off; Up 0.0.0.0:85->80/tcp
第五步：准备测试页面，访问测试
[root@master ~]# echo “123”>/data/nginx/www/1.html
第六步：修改yaml文件
[root@master ~]# vim docker-compose.yml
version: '3'
services:
web:
image: nginx:1.17.9
restart: always
container_name: myweb
ports:
- 85:80
depends_on:
- php
links：
- php
volumes:
- "/data/nginx/www:/www/html"
- "/data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf"
php:
image: php:5.6-fpm
container_name: myphp
restart: always
volumes:
- "/data/nginx/www:/www/html"
第七步：修改nginx的配置文件，兼容php
[root@master ~]# vim /data/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;
server {
listen 80;
server_name localhost;
location / {
root /www/html;
index index.html index.htm;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
location ~ \.php$ {
root /www/html;
fastcgi_pass php:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
}
}
- 85:80
volumes:
- "/data/nginx/www:/www/html"
- "/data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf"
php:
image: php:5.6-fpm
container_name: myphp
restart: always
depends_on:
- web
volues:
- "/data/nginx/www:/www/html"
第八步：执行yaml文件，并查看容器状态
[root@master ~]# docker-compose up -d
[root@master ~]# docker-compose ps
第九步：编写php测试页
[rooot@master ~]# cd /data/nginx/www/
[root@master html]# vim a.php
案例：通过compose部署nginx+php
1：准备volume用的目录
[root@master ~]# mkdir /data/nginx/{www,conf} -pv
mkdir: created directory ‘/data’
mkdir: created directory ‘/data/nginx’
mkdir: created directory ‘/data/nginx/www’
mkdir: created directory ‘/data/nginx/conf’
2、准备nginx配置文件
[root@master ~]# cd /data/nginx/conf/
[root@master conf]# cp /etc/nginx/nginx.conf ./
[root@master conf]# ls
nginx.conf
3、编写docker-compose部署nginx
docker镜像仓库
- 存储docker镜像文件
概念：
- registry
- repositry
安装方法
-
在线
-
离线
-
离线安装包：https://storage.googleapis.com/harbor-releases/harbor-offline-installer-v1.5.4.tgz
安装harbor的要求
- 2 核CPU
- 2G内存
安装harbor
1）解压
[root@node2 ~]# tar xvf harbor-offline-installer-v1.5.4.tgz
2）修改配置文件
[root@node2 ~]# vim harbor/harbor.cfg
修改harbor配置文件的主机名部分
hostname = node2
3）启动harbor
[root@node2 harbor]# ./prepare
[root@node2 harbor]# ./install.sh
4）检查一下
[root@node2 harbor]# docker ps
5）登录harbor
- http://ip
- 账号：admin
- 密码：Harbor12345
使用harbor
1）创建项目
创建两个项目，每个项目对应一类镜像的
- nginx项目，存储nginx镜像
- php项目，存储php镜像
鼠标点击实现，略
2）准备镜像文件
将myphp 1.0镜像推送到harbor
第一步：修改镜像的标签
重启harbor
[root@sql ~]# cd harbor
[root@sql harbor]# docker-compose down
[root@sql harbor]# rm -rf /data*
[root@sql harbor]# ./prepare
[root@sql harbor]# ./install.sh
docker^C7的服务器，检测网络正常
请基于Centos镜像构建Nginx环境
-
准备一台Centos7的服务器，检测网络正常
-
检查服务器docker运行是否正常，如没有请安装
[root@master ~]# yum install docker -y
[root@master ~]# vim /etc/docker/daemon.json
{
"registry-mirrors": ["https://mzxx8xy8.mirror.aliyuncs.com"]
}
[root@master ~]# systemctl start docker
[root@master ~]# docker info
- 请检查本机是否有Centos镜像，如没有请下载镜像
[root@master ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
[root@master ~]#
[root@master ~]# docker pull centos:7
- 请创建一个nginx目录，以此目录作为构建镜像目录
[root@master ~]# mkdir /nginx
- 请编写测试页面index.html,内容为自定
[root@master ~]# cd /nginx/
[root@master nginx]# echo "test for my page">index.html
- 请编写Dockerfile构建Nginx镜像，基础镜像为centos，新镜像名字为：nginx:v1.0，并将自定义的测试页面复制到容器中
root@master ~]# cd /nginx/
[root@master nginx]# vim Dockerfile
FROM centos:7
RUN yum install gcc gcc-c++ make pcre-devel zlib-devel ncurses-devel -y
ADD http://nginx.org/download/nginx-1.16.1.tar.gz /tmp/
RUN cd /tmp && tar xf nginx-1.16.1.tar.gz
WORKDIR /tmp/nginx-1.16.1
RUN ./configure --prefix=/usr/local/nginx
RUN make && make install
RUN echo 'daemon off;'>>/usr/local/nginx/conf/nginx.conf
COPY index.html /usr/local/nginx/html/
CMD ["/usr/local/nginx/sbin/nginx"]
ENTRYPOINT ["/bin/sh","-c"]
- 成功构建nginx:v1.0镜像
[root@master ~]# cd /nginx/
[root@master nginx]# docker build -t nginx:v1.0 .
- 请基于nginx:v1.0镜像，运行一个新的容器
[root@master nginx]# docker run --name myngx -d --rm nginx:v1.0
- 请将容器的80端口映射在宿主机的80端口上
[root@master nginx]# docker run --name myngx -d --rm -p 80:80 nginx:v1.0 /usr/local/nginx/sbin/nginx
- 访问测试，成功访问到自定义的测试页面
略
案例-11-2
构建LAMP镜像并发布电商
1、 准备一台Centos7的服务器，检测网络正常
2、 检查服务器docker运行是否正常，如没有请安装
3、 请编写Dockerfile构建Apache+php+mysql镜像要求如下：
a) 基础镜像为Centos
b) 将/var/www/html目录作为挂载点
c) 暴漏端口：80
d) 构建镜像名字为lamp:1.1
4、 请基于lamp：1.1镜像运行一个容器，要求如下：
a) 容器名字为ds
b) 将/opt/html挂载到容器的/var/www/html目录下
c) 将宿主机的80端口映射到容器的80端口
5、 上传电商项目包到web服务器发布目录
6、 成功发布
案例-12-1
1、 案例题目
请基于Centos镜像构建Nginx环境
2、 思路要求
-
准备一台Centos7的服务器，检测网络正常
-
检查服务器docker运行是否正常，如没有请安装
-
请检查本机是否有Centos镜像，如没有请下载镜像
-
请创建一个nginx目录，以此目录作为构建镜像目录
-
请编写测试页面index.html,内容为自定
-
请编写Dockerfile构建Nginx镜像，基础镜像为centos，新镜像名字为：nginx:v1.0，并将自定义的测试页面复制到容器中
-
成功构建nginx:v1.0镜像
-
请基于nginx:v1.0镜像，运行一个新的容器
-
请将容器的80端口映射在宿主机的80端口上
-
访问测试，成功访问到自定义的测试页面
案例-12-2 【4月1日作业】
1、 案例题目
构建Tomcat镜像并发布solo博客
2、 思路要求
1、 准备一台Centos7的服务器，检测网络正常
2、 检查服务器docker运行是否正常，如没有请安装
3、 请编写Dockerfile构建Tomcat镜像要求如下：
a) 基础镜像为java
b) tomcat版本为8.5
c) 将webapps目录作为挂载点
d) 暴漏端口：8080和8443
e) 构建镜像名字为tomcat：1.1
第一步：下载tomcat镜像文件
http://mirror.hust.edu.cn/apache/tomcat/tomcat-8/v8.5.51/bin/apache-tomcat-8.5.51.tar.gz
第二步：编写Dockerfile文件
FROM centos:7
RUN yum install java-1.8.0-openjdk iproute -y
ADD apache-tomcat-8.5.51.tar.gz /usr/local/
EXPOSE 8080
EXPOSE 8443
VOLUME ["/usr/local/apache-tomcat-8.5.51/webapps/ROOT/"]
CMD ["/bin/bash","-c","/usr/local/apache-tomcat-8.5.51/bin/catalina.sh run"]
4、 请基于tomcat：1.1镜像运行一个容器，要求如下：
a) 容器名字为solo
b) 将/opt/html挂载到tomcat的webapps目录下
c) 将宿主机的80端口映射到容器的8080端口
[root@master ~]# mkdir /opt/html
[root@master ~]# docker run --name solo --rm -d -p 80:8080 -v /opt/html/:/usr/local/apache-tomcat-8.5.51/webapps/ROOT/ tomcat:1.3
5、 上传solo博客到服务器，并修改访问url和端口
6、 成功发布solo博客
案例-13-1
1、 案例题目
使用docker部署Nginx
2、 思路要求
1 准备一台Centos7的服务器，检测网络正常
2 检查服务器docker运行是否正常，如没有请安装
3 请基于busybox镜像构建自己的镜像，要求运行镜像后打印“Hello Docker”
4 请使用docker下载Nginx镜像，并查看验证下载成功
5 请基于Nginx镜像构建自定义的Nginx镜像：
要求：
\1. 新镜像名字为：自己的名字-Nginx
\2. Nginx暴露端口为80和443
\3. Nginx默认测试页面修改为：“Welcome to Nginx!”
\4. 将Nginx的网站根目录设置为匿名卷挂载点
6 请基于你的Nginx镜像运行一个新的容器，容器名为nginx ,需将容器的80端口映射在宿主机的80端口上，容器要以守护进程运行
7 请访问测试，容器运行正常
案例-13-2
1、 案例题目
构建Tomcat镜像并发布solo博客
2、 思路要求
1、 准备一台Centos7的服务器，检测网络正常
2、 检查服务器docker运行是否正常，如没有请安装
3、 请编写Dockerfile构建Tomcat镜像要求如下：
a) 基础镜像为java
b) tomcat版本为8.5
c) 将webapps目录作为挂载点
d) 暴漏端口：8080和8443
e) 构建镜像名字为tomcat：1.1
4、 请基于tomcat：1.1镜像运行一个容器，要求如下：
a) 容器名字为solo
b) 将/opt/html挂载到tomcat的webapps目录下
c) 将宿主机的80端口映射到容器的8080端口
5、 上传solo博客到服务器，并修改访问url和端口
6、 成功发布solo博客
案例-week-12
**（一）**实验一：docker实战
1） 准备两台服务器，安装部署docker .
2） 设置镜像加速 .
在其中一台操作如下
3） 创建zabbix数据库数据卷/data/zabbix/mysql .
4） 运行基于mysql:5.7的容器并挂载上题数据卷、配置zabbix数据库、数据库用户等信息。 .
5） 运行基于zabbix-server-mysql容器并配置相关信息，连接4)中容器 .
6） 运行基于zabbix-web-nginx-mysql 容器并配置相关信息，连接4）、5）中容器 .
在另一台上操作如下
7） 运行基于zabbix-agent的容器并配置host主机等信息 .
8） 访问zabbix首页并配置相关信息 .
9） 创建自动发现监控zabbix-agent .
**（二）实验二：docker实战部署电商项目 4.
1）Docker查看镜像仓库中lnmp镜像并拉取 .
2）创建lnmp+电商项目所需数据卷 .
3）运行基于lnmp的容器挂载数据卷并做端口映射 .
4）上传Dz包到宿主机对应挂载目录下 .
5） 进入容器查看是否解压成功并授予可写权限 .
6）进入镜像启动相关服务 .
7）创建基于mysql镜像的容器并配置相关参数 .
8）使用命令查看lnmp容器元数据 .
9）成功访问Dz首页并成功配置 .
**（三）****实验三：shell
1）每周日晚23点，对数据库服务器上的webdb库做完整备份
2）备份文件保存到系统的/mysqlbak目录里
3）用系统日期做备份文件名webdb-年-月-日.sql
4）每次完整备份后都生成新的binlog日志
5）把当前所有binlog日志备份到/mysqlbinlog目录下
案例-week-11
**（一）Docker实战
\1. 安装docker
编写dockerfile创建apache镜像
\2. FROM命令正确
\3. 安装命令正确
\4. 将测试页面显示内容改为hello world ！
\5. 前台启动命令zhengq
\6. 编写Dockerfile并构建
\7. 查看镜像
8. 创建容器测试并访问页面
**（二）docke-compose实战
\1. 安装docker,若安装请先删除
使用docker-compose部署zabbix监控mysql，所有操作需写在zabbix.yml中，否则0分
\2. 编写mysql服务,基础镜像为mysql:5.6
\3. mysql端口映射命令正确 .
\4. 环境变量设置正确
\5. 编写zabbix-server服务，基础镜像为zabbix-server
\6. 端口映射命令正确，Zabbix环境变量设置正确
\7. 编写zabbix-web服务，基础镜像从服务器中选择
\8. 端口映射命令正确，环境变量设置正确
\9. 成功运行zabbix.yml并访问
案例-week-1
**（一）****实验一：docker Harbor私有仓库搭建
1） 安装部署docker-compose 编排工具 .
2） 下载Habor并且解压
3） 编辑habor配置文件，修改hostname为本机ip地址
4） 设置habor web平台登录账户admin，修改密码为wg123456
5） 启动Harbor服务
6） 新增项目名为wordpress，设置为公开 .
7） 创建用户wg01 并分配权限，可以正常上传下载镜像 .
**（二）****实验二：docker实战部署wordpress 6.
1）在/usr/local/src 下新建目录 wordpress .
2）进入wordpress目录下，编辑wordpress.yaml .
3） 指定所创建镜像的基础镜像 .
4）将容器数据卷/var/lib/mysql挂载到本地/mysql/data下 .
5）设置自动重启.
6）指定mysql的root账号初始密码为123456 .
7）指定容器 启动后要创建的数据库为wordpress .
8）指定容器在启动后要创建的普通用户tom，授权允许远程登录mysql .
9）设置tom的远程登录密码为123456 .
10）将容器的80端口映射到本地的8080上 .
11）构建并运行项目 .
12）浏览器访问8080端口，登录wordpress安装界面 .
13）将wordpress镜像打个tag wg01并上传到私有仓库 .
卸载清除harbor
[root@sql ~]# cd harbor
[root@sql harbor]# docker-compose down
[root@sql harbor]# rm -rf /data*
[root@sql harbor]# ./prepare
[root@sql harbor]# ./install.sh
案例-week-3
**（一）**实验一：docker Harbor私有仓库搭建
1） 安装部署docker-compose 编排工具
- 第一步：上传docker-compose到虚拟机
- 第二步：chmod +x docker-compose
- 第三步：mv docker-compose /bin/
2） 下载Habor并且解压
- 第一步：上传安装包
- 第二步：tar xvf 安装包 tar xvf harbor-offline-installer-v1.5.4.tgz
3） 编辑habor配置文件，修改hostname为本机ip地址
[root@node2 ~]# cd harbor
[root@node2 harbor]# vim harbor.cfg
修改一行
hostname = 192.168.31.66
4） 设置habor web平台登录账户admin，修改密码为123
[root@node2 ~]# cd harbor
[root@node2 harbor]# vim harbor.cfg
修改一行
harbor_admin_password = 123
5） 启动Harbor服务
[root@node2 ~]# cd harbor
[root@node2 harbor]# ./prepare
[root@node2 harbor]# ./install.sh
6） 正常登陆harbor
- 在浏览器访问harbor服务器的地址
- 账户：admin
- 密码：123
7） 新增项目名为wordpress，设置为公开
- 鼠标点击新建项目
- 勾选公开
8） 创建用户wg01 并分配权限，可以正常上传下载镜像
- 鼠标点击用户管理
- 密码要是8，而且要包含数字、小写、大写
**（二）****实验二：docker实战部署wordpress **
9） 在/usr/local/src 下新建目录 wordpress
[root@sql ~]# mkdir /usr/local/src/wordpress
10） 进入wordpress目录下，编辑wordpress.yaml
[root@sql ~]# cd /usr/local/src/wordpress
[root@sql wordpress]# vim wordpress.yaml
11） 指定所创建镜像的基础镜像
12） 将容器数据卷/var/lib/mysql挂载到本地/mysql/data下
13） 指定mysql的root账号初始密码为123456
14） 指定容器 启动后要创建的数据库为wordpress
15） 指定容器在启动后要创建的普通用户tom，授权允许远程登录mysql
16） 设置tom的远程登录密码为123456
17） 将容器的80端口映射到本地的8080上
yaml中的内容
version: '3.1'
services:
wordpress:
image: wordpress
restart: always
ports:
- 8080:80
environment:
WORDPRESS_DB_HOST: db
WORDPRESS_DB_USER: tom
WORDPRESS_DB_PASSWORD: 123456
WORDPRESS_DB_NAME: wordpress
db:
image: mysql:5.7
restart: always
environment:
MYSQL_DATABASE: wordpress
MYSQL_USER: tom
MYSQL_PASSWORD: '123456'
MYSQL_RANDOM_ROOT_PASSWORD: '123456'
volumes:
- /var/lib/mysql:/mysql/data
18） 构建并运行项目
[root@node2 wordpress]# docker-compose -f wordpress.yaml up -d
[root@node2 wordpress]# docker-compose -f wordpress.yaml ps
19） 浏览器访问8080端口，登录wordpress安装界面
- ip:8080
- 为了避免乱码，选择英文
20） 将wordpress镜像打个tag wg01并上传到私有仓库
第一步：信任私有镜像仓库-harbor
修改docker配置文件
[root@node2 ~]# vim /etc/docker/daemon.json
{
"registry-mirrors": ["https://mzxx8xy8.mirror.aliyuncs.com"],
"insecure-registries": ["192.168.31.66"]
}
重启docker
[root@node2 ~]# systemctl daemon-reload
[root@node2 ~]# systemctl restart docker
第二步：按照harbor提示，给镜像打标签
[root@node2 ~]# docker tag docker.io/wordpress:latest 192.168.31.66/wordpress/wordpress:01
第三步：登录harbor
[root@node2 ~]# docker login 192.168.31.66
Username: admin
Password:
Login Succeeded
第四步：上传镜像文件
[root@node2 ~]# docker push 192.168.31.66/wordpress/wordpress:01
第四步：退出登录
[root@node2 ~]# docker logout
放假安排：
- 周五上午上课，下午放假
- 周六、周日放假
- 周一周考
案例：基于compose部署lnmp
- 结合dockerfile自动构建镜像
第一步：部署nginx
1）准备nginx的配置文件
[root@node2 ~]# mkdir /data/nginx/{conf,www} -pv
[root@node2 ~]# cp //etc/nginx/nginx.conf.default /data/nginx/conf/nginx.conf
[root@node2 ~]# vim /data/nginx/conf/nginx.conf
- 配置文件修改的网络根目录是/data/html
2）编写docker-compose
[root@node2 ~]# cat docker-compose.yaml
version: '3'
services:
nginx:
image: nginx:1.17.9
restart: always
container_name: nginx
ports:
- 80:80
volumes:
- /data/nginx/www:/data/html
- /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
启动容器
[root@node2 ~]# docker-compose up -d
[root@node2 ~]# docker-compose ps
Name Command State Ports
---------------------------------------------------------
nginx nginx -g daemon off; Up 0.0.0.0:80->80/tcp
准备nginx的测试页
[root@node2 ~]# echo "test page
">/data/nginx/www/index.html
访问测试：http://192.168.1.66/index.html
第二步：部署php
1）制作php镜像
[root@node2 ~]# mkdir php
[root@node2 ~]# cd php
[root@node2 php]# cat Dockerfile
FROM centos:7
RUN yum install php php-fpm php-mysql php-devel php-gd -y
RUN sed -i "s/listen = 127.0.0.1:9000/listen = 0.0.0.0:9000/g" /etc/php-fpm.d/www.conf
RUN sed -i "s/listen.allowed_clients = 127.0.0.1/; listen.allowed_clients = 127.0.0.1/g" /etc/php-fpm.d/www.conf
EXPOSE 9000
CMD ["/bin/bash","-c","/usr/sbin/php-fpm"]
2）编写compose文件部署php
version: '3'
services:
nginx:
image: nginx:1.17.9
restart: always
container_name: nginx
ports:
- 80:80
volumes:
- /data/nginx/www:/data/html
- /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
php:
build:
context: ./php/
dockerfile: Dockerfile
volumes:
- /data/nginx/www:/data/html
修改nginx配置文件，让nginx链接php
[root@node2 ~]# vim /data/nginx/conf/nginx.conf
location ~ \.php$ {
root /data/html;
fastcgi_pass php:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
通过docker-compose启动服务
[root@node2 ~]# docker-compose up -d
[root@node2 ~]# docker ps
编写php测试页面，并测试
[root@node2 ~]# cd /data/nginx/www/
[root@node2 www]# vim test.php
第三步：部署mysql
1）修改docker-compose
version: '3'
services:
nginx:
image: nginx:1.17.9
restart: always
container_name: nginx
ports:
- 80:80
links:
- php
volumes:
- /data/nginx/www:/data/html
- /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
php:
build:
context: ./php/
dockerfile: Dockerfile
#restart: always
#container_name: php
links:
- mysql
volumes:
- /data/nginx/www:/data/html
mysql:
image: mysql:5.7
restart: always
container_name: mysql
environment:
MYSQL_ROOT_PASSWORD: 123
MYSQL_USER: dbuser
MYSQL_PASSWORD: 123
2）编写测试mysql的页面
[root@node2 ~]# vim /data/nginx/www/conn.php