Docker基础入门实战
1.Win10安装Docker
-
Docker for Win10 安装包下载地址：
-
国内镜像加速
-
- https://registry.docker-cn.com/ #Docker中国区
- http://hub-mirror.c.163.com/ #网易
2.Centos7安装Docker
如何在Linux环境下安装docker
- 安装环境：Centos 7
- 安装条件：Docker官方要求至少3.8以上，建议3.10以上
- Docker 版本：Docker EE 企业版本、Docker CE 社区版本
环境查看
# 系统内核是 3.10 以上的
[root@localhost ~]# uname -r
3.10.0-957.el7.x86_64
[root@localhost ~]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"
CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"
安装
# 准备工作
# 关闭防火墙（新手建议关闭，熟练Linux可以忽略）
systemctl stop firewalld.service
# 将SELINUX的值改成disabled
vi /etc/selinux/confifig 或者 vi /etc/sysconfig/selinux
# 下载阿里云docker社区版 yum源：
# 方式一：
$ yum -y install wget
$ wget -P /etc/yum.repos.d/ http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 方式二：
$ yum-config-manager \
--add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 正式开始安装Docker
# 1.查看Docker安装包：
$ yum list | grep docker
# 2.安装Docker CE 社区版本：
$ yum install -y docker-ce.x86_64
# 3.更新xfsprogs（可更可不更）：
$ yum -y update xfsprogs
# 4.启动docker：
$ systemctl start docker
# 5.设置开机启动：
$ systemctl enable docker
# 6.查看版本：
$ docker version
# 7.查看详细信息：
$ docker info
# 8.Docker内万能详情命令查询：inspect
$ docker inspect 镜像名/镜像id/容器名/容器id/网络名/网络id/数据卷名/卷id...
# 帮助命令
$ docker 命令 --help
官网安装版本：
# 1、Docker 要求 CentOS 系统的内核版本高于3.10，安装前提条件先验证你的CentOS版本是否支持 Docker
# 命令查看你当前的内核版本
$ uname -r
# 2、使用 root 权限登录 Centos。确保 yum 包更新到最新。
$ sudo yum update
# 3、卸载旧版本(如果安装过旧版本的话)
$ sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
# 4、安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的
$ sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# 5、设置yum源
# 国外默认的镜像
$ sudo yum-config-manager \
--add-repo https://download.docker.com/linux/centos/docker-ce.rep
# 阿里云镜像加速
$ sudo yum-config-manager \
--add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 6、安装docker
# 由于repo中默认只开启stable仓库，故这里安装的是最新稳定版17.12.0
$ sudo yum install docker-ce docker-ce-cli containerd.io
============================================================================
# 可以查看所有仓库中所有docker版本，并选择特定版本安装
$ yum list docker-ce --showduplicates | sort -r
Installed Packages
docker-ce.x86_64 3:19.03.9-3.el7 docker-ce-stable
docker-ce.x86_64 3:19.03.8-3.el7 docker-ce-stable
docker-ce.x86_64 3:19.03.7-3.el7 docker-ce-stable
# 选择版本下载
sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io
sudo yum -y install docker-ce-19.03.5 docker-ce-cli-19.03.5 containerd.io
官网卸载篇
1、查询安装过的包
$ yum list installed | grep docker
2、删除安装的软件包
$ sudo yum remove docker-ce docker-ce-cli containerd.io
3、删除镜像/容器等
$ rm -rf /var/lib/docker
3.Docker阿里云镜像加速
# 1.配置步骤：
$ vi /etc/docker/daemon.json
# 2.写入一下内容到文件中
{
"registry-mirrors": ["https://a32yzw3z.mirror.aliyuncs.com"]
}
# 3.重启：
$ systemctl daemon-reload && systemctl restart docker
或者
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://a32yzw3z.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
4.Docker镜像基本操作
# 搜索镜像：
$ docker search centos
# 搜索镜像并过滤是官方的：
$ docker search --filter "is-official=true" centos
# 搜索镜像并过滤大于多少颗星星的：
$ docker search --filter stars=10 centos
# 下载centos7镜像：
$ docker pull centos:7
# 查看本地镜像：
$ docker images
$ docker image ls
# 本地镜像的删除：
$ docker rmi -f centos:7
# 修改本地镜像名字（小写）相当于拷贝一个改一个名字：
$ docker tag centos:7 mycentos:1
# 保存镜像为文件：
$ docker save -o /home/centos7 centos:7
$ docker save --output /home/centos7 centos:7
# 通过文件导入镜像：
$ docker load -i /srv/ubuntu-cs.latest
$ docker load --input /srv/ubuntu-cs.latest
# 查看容器详细信息
$ docker image inspect 容器名称/容器ID
# 查看镜像变更历史：history
$ docker history 镜像ID
$ docker history 80b97bbc4a6c
# 查看帮助docker image帮助文档
[root@VM_0_14_centos ~]# docker image --help
build Build an image from a Dockerfile
history Show the history of an image
import Import the contents from a tarball to create a filesystem image
inspect Display detailed information on one or more images
load Load an image from a tar archive or STDIN
ls List images
prune Remove unused images
pull Pull an image or a repository from a registry
push Push an image or a repository to a registry
rm Remove one or more images
save Save one or more images to a tar archive (streamed to STDOUT by default)
tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
6.Docker容器基本操作
简介：Docker容器的创建，查看，停止，重启等
# 创建容器（构建容器）
-i ：表示以交互模式运行容器（让容器的标准输入保持打开）
-d：表示后台运行容器，并返回容器ID
-t：为容器重新分配一个伪输入终端
-p：指定容器的端口：-p 8080:8080
-P：随机指定端口
--name：为容器指定名称
$ docker run -itd --name=mycentos centos:7
# 查看本地正在运行的容器：
$ docker ps
$ docker container ls
# 查看本地所有的容器：
$ docker ps -a
$ docker container ls -a
# 停止容器：
$ docker stop 容器id / 容器名称
# 一次性停止所有容器：
$ docker stop $(docker ps -q -a)
$ docker stop $(docker ps -qa)
# 启动容器：
$ docker start 容器id / 容器名称
# 重启容器：
$ docker restart 容器id / 容器名称
# 删除容器：
$ docker rm 容器id / 容器名称
# 强制删除容器：
$ docker rm -f 容器id / 容器名称
# 查看容器详细信息：
$ docker inspect 容器id / 容器名称
# 保存容器：
$ docker export 容器id / 容器名称 -o /home/test-export.tar
# 载入容器(导入后会编程镜像，需要重新启动)：
$ docker import /home/test-export.tar text:v1
# 进入容器：
$ docker exec -it 容器id /bin/bash
$ docker exec -it 容器id bash # 我一般用这个
# 启动并且进入容器（重要），
# 注意：在使用/bin/bash 进入容器时，不要加-d，需要加-it。
$ docker run -it --name=mycentos centos:7 /bin/bash
# 备注
ctrl+d 退出容器且关闭, docker ps 查看无
ctrl+p+q 退出容器但不关闭（后台运行）, docker ps 查看有
7.Docker常用命令总结
查看日志 logs
# 现在容器没有日志
docker logs -f -t --tail 10 容器
# 自己编写一段shell脚本
docker run -d centos /bin/bash -c "while true;do echo kuangshen;sleep 1;done"
[root@localhost docker]# docker ps
CONTAINER ID IMAGE .....
d97e8c1883af centos .....
-t # 加入时间戳
-f # 跟随最新的日志打
--tail number # 要显示日志条数
$ docker logs [参数] 容器id/名称
$ docker logs -tf d97e8c1883af
查看容器中的进程 ps
# 命令 docker top 容器id
[root@localhost docker]# docker top d97e8c1883af
UID PID PPID C STIME TTY TIME
root 15626 15611 0 20:07 ? 00:00:00
root 16176 15626 0 20:13 ? 00:00:00
查看镜像/容器/网络/数据卷/的元数据 inspect
$ docker inspect 镜像名/镜像id/容器名/容器id/网络名/网络id/数据卷名/卷id...
或者
$ docker image inspect 镜像名/镜像id
$ docker container inspect 容器名/容器id
$ docker volume inspect 网络名/网络id
$ docker network inspect 数据卷名/卷id
进入当前正在运行的容器
# 我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
# 命令
# 方式一：
docker exec -it 容器id/名称 bash
docker exec -it 容器id/名称 /bin/bash
# 方式二：
docker attach 容器id/名称
# 区别：
# docker exec 进入容器后开启一个新的终端，可以在里面操作（常用）
# docker attach 进入容器正在执行的终端，不会启动新的进程
命令小结
attach # 当前shell下 attach连接指定运行的镜像
build # 通过Dockerfile定制镜像
commit # 提交当前容器为新的镜像
cp # 拷贝文件
create # 创建一个新的容器
diff # 查看docker容器的变化
events # 从服务获取容器实时时间
exec # 在运行中的容器上运行命令
export # 导出容器文件系统作为一个tar归档文件[对应import]
history # 展示一个镜像形成历史
images # 列出系统当前的镜像
import # 从tar包中导入内容创建一个文件系统镜像
info # 显示全系统信息
inspect # 查看容器详细信息
kill # kill指定docker容器
load # 从一个tar包或标准输入中加载一个镜像[对应save]
login # 登录Docker远程仓库
logout # 退出Docker远程仓库
logs # 查看容器的日志
pause # 暂停一个或多个容器中的所有进程
port # 列出端口映射或容器的特定映射
ps # 列出容器（正在运行的）
pull # 从repository下载镜像image
push # 上传镜像到远程仓库
rename # 给容器重命名
restart # 重启一个容器
rm # 删除一个或者多个容器
rmi # 删除一个或者多个镜像
run # 启动运行一个容器
save # 将一个或多个镜像保存到tar存档（默认情况下流式传输到STDOUT）
search # 在Docker Hub中搜索镜像
start # 启动一个或多个已停止的容器
stats # 显示实时的容器资源使用情况统计流
stop # 停止一个或多个运行中的容器
tag # 创建一个引用了SOURCE_IMAGE的标签TARGET_IMAGE（意思就是拷贝一个镜像给他该一个tag名称）
top # 显示容器的运行过程
unpause # 取消暂停一个或多个容器中的所有进程
update # 更新一个或多个容器的配置
version # 显示Docker版本信息
wait # 阻塞直到一个或多个容器停止，然后打印其退出代码
8.Docker容器挂载同步和复制
简介：容器与宿主机之间文件复制与挂载
复制：
# 从宿主机复制到容器：docker cp 宿主机本地路径 容器名字/ID：容器路径
docker cp /root/123.txt mycentos:/home/
# 从容器复制到宿主机：docker cp 容器名字/ID：容器路径 宿主机本地路径
docker cp mycentos:/home/456.txt /root
容器数据卷挂载分为3种形式：
- 匿名挂载：-v 容器路径。（在/var/lib/docker/volumes/xxx/_data 随机生成文件夹 ）
- 具名挂载：-v 卷名:容器路径（在/var/lib/docker/volumes/卷名/_data 生成文件夹）
- 指定路径挂载：-v 宿主机路径:容器路径（目录不存在会自动创建）
# 1.匿名挂载
$ docker run -d -v 容器路径
$ docker run -d -v /etc/nginx nginx
# 2.具名挂载
$ docker run -d -v 卷名:容器路径 nginx
$ docker run -d -v juming-nginx:/etc/nginx nginx
# 3.指定路径挂载(目录不存在会自动创建)
$ docker run -it -v 主机目录:容器目录
$ docker run -it -v /volumeFile/:/volumeFile centos:7
# 查看具名数据卷和匿名数据卷
$ docker volume ls
DRIVER VOLUME NAME
local 4f20fd270e17181eaa646de0cb2a1e121...
local juming
# 查看某个数据卷
$ docker volume inspect 卷名/匿名卷ID
其实等价于
$ docker inspect 卷名/匿名卷ID
$ docker volume inspect juming-nginx
[
{
"CreatedAt": "2020-05-25T02:01:18+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
"Name": "juming-nginx",
"Options": null,
"Scope": "local"
}
]
# 查看一下卷挂载路径
$ docker inspect 容器id / 容器名称
$ docker inspect kuangshen/centos:1.0
$ docker inspect 1da06549f6a6
[
...........
"Mounts": [
{
"Type": "volume",
"Name": "cc69b9945870ef5b9191b197667bd52eaec9f8742c9bf036a411ca579b47575e",
"Source": "/var/lib/docker/volumes/cc69b9945870ef5b9191b197667bd52eaec9f8742c9bf036a411ca579b47575e/_data",
"Destination": "volume01",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
},
{
"Type": "volume",
"Name": "86bb36e012b13c33853fa1a917f4494e30d196a4eddf70f128c0e558d808f3be",
"Source": "/var/lib/docker/volumes/86bb36e012b13c33853fa1a917f4494e30d196a4eddf70f128c0e558d808f3be/_data",
"Destination": "volume02",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
]
]
拓展：ro rw读写权限
# 通过 -v 容器内路径:ro rw 改变读写权限
ro readonly # 只读
rw readwrite # 可读可写
# 一旦设置了这个权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx
# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！
# rw 默认
各容器中数据卷同步
# 前提：该容器必须挂载目录（无论具名匿名还是直接路径挂载都行）
# 首先启动docker01容器
docker run -it --name docker01 -v /volumedir centos:7
# 启动docker02，并且挂载上docker01容器
# 强调：--volumes-from 挂载的容器必须的先挂载目录
docker run -it --name docker02 --volumes-from docker01 centos:7
# 备注：
# 这样docker01和docker02中的volumedir目录中的数据就同步了，自行测试。
# 如果在启动一个docker03继续挂载docker01，那么三个容器目录都是同步共享的了
# 如果在启动一个docker03继续挂载docker02，同样三个容器目录都是同步共享的了
# 删除docker01容器，查看docker02和docker03中的文件依旧存在
Docker自定义镜像实战
1.Docker自定义镜像介绍
介绍自定义镜像的重要性
-
Docker目前镜像的制作有俩种方法：
-
- 基于Docker Commit制作镜像
- 基于Dockerfile制作镜像，Dockerfile方式为主流的制作镜像方式
2.Commit构建自定义镜像
对容器的修改以及保存
# 启动并进入容器：
$ docker run -it centos:7 /bin/bash
# 在/home 路径下创建commitdir文件夹：
$ mkdir /home/commitdir
# 安装ifconfig命令：
$ yum -y install net-tools
# 重启容器，查看容器的commitdir文件夹还在不在：
$ docker restart 67862569d4f7
# 删除容器，再重新启动一个容器进入查看有没有commitdir文件夹：
$ docker rm 67862569d4f7 && docker run -it --name centos1 centos:7 bash
# 可以发现容器删除之后，之前的操作都没有了.
# 现在我们想保留之前容器中的操作，那么可以把该容器也提交保存为一个镜像。
# 构建镜像：
-a：标注作者
-m：说明注释
$ docker commit 容器名称/id 新镜像名称:tag
$ docker commit centos1 mycentos:7
$ docker commit -a "lsx" -m "mkdir /home/commitdir" centos1 mycentos:7
# 查看镜像详细信息：
$ docker inspect mycentos:7
# 启动并进入容器：
$ docker run -itd mycentos:7 /bin/bash
3.DockerFile构建镜像实战
3.1.DockerFile命令详解
Dockerfile常用的指令
https://www.cnblogs.com/python-gm/p/12470762.html#_caption_0
| 指令 | 描述 |
|---|---|
| FROM | 基础镜像，一切从这里开始构建，基于哪个镜像 |
| MAINTAINER | 注明作者， 姓名+邮箱 |
| COPY | 复制文件进入镜像（只能用相对路径，不能用绝对路径） |
| ADD | 复制文件进入镜像并解压（假如文件是.tar.gz文件会解压） |
| WORKDIR | 指定工作目录，如路径不存在会自动创建。后面可以通过$ 取值使用 |
| ENV | 设置环境变量。后面可以通过 $ 取值进行使用 |
| RUN | 在构建镜像的时候执行，作用于镜像层面 |
| CMD | 指定这个容器启动的时候要运行的命令，只有最后一个会生效。 可被替代。可被docker run 提供的参数覆盖 |
| ENTRYPOINT | 配置容器启动后执行的命令，并且不可被 docker run 提供的参数覆盖 每个Dockerfile中只能有一个 ENTRYPOINT，当指定多个 ENTRYPOINT 时，只有最后一个生效 |
| ARG | ARG和ENV效果类似，都是用来设置观景变量的。 唯一 不同的是dockerfile中的ARG编译好后是不会出现在打开的容器内的。 |
| VOLUME | 挂载的目录 |
| USER | 为RUN,CMD,ENTRYPOINT执行命令指定运行用户例如：USER www镜像构建完成后，通过docker run运行容器时，可以通过-u参数来覆盖所指定的用户 |
| EXPOSE | 暴漏端口（只是把暴露端口出去，最后映射端口还是需要启动容器指定） |
3.2.DockerFIle构建镜像
DockerFile快速入门
$ cd /home
$ vi dockerfile
# this is a dockerfile
FROM centos:7
MAINTAINER LSX 123456@qq.com
RUN echo "正在构建镜像！！！"
WORKDIR /home/dockerfileDIR
COPY 123.txt /home/dockerfileDIR
RUN yum install -y net-tools
- 执行DockerFile文件
# 语法：docker build [OPTIONS] PATH | URL | -
# 命令：docker build -f 文件路径 -t 镜像名:[tag] .
$ docker build -t mycentos:v2 .
$ docker build -f /home/dockerfile -t mycentos:v2 .
$ docker images
-
RUN、CMD 及 ENTRYPOINT 命令的区别：
- RUN、CMD、ENTRYPOINT 单条命令执行对比
=========================================== # 第一种：RUN、CMD、ENTRYPOINT 单条命令执行对比 =========================================== FROM centos:7 RUN echo "images building!" CMD ["echo","container","starting..."] ENTRYPOINT ["echo","container","starting ！！！"] # 执行构建 $ docker build -t mycentos:v1 . Sending build context to Docker daemon 3.072kB Step 1/4 : FROM centos:7 7: Pulling from library/centos 524b0c1e57f8: Pull complete Digest: sha256:e9ce0b76f29f942502facd849f3e468232492b259b9d9f076f71b392293f1582 Status: Downloaded newer image for centos:7 ---> b5b4d78bc90c Step 2/4 : RUN echo "images building!" ---> Running in 2f64230f73e3 images building! Removing intermediate container 2f64230f73e3 ---> 9d2fb8c68089 Step 3/4 : CMD ["echo","container","starting..."] ---> Running in 5c034ca0edd8 Removing intermediate container 5c034ca0edd8 ---> a147e245432a Step 4/4 : ENTRYPOINT ["echo","container","starting ！！！"] ---> Running in e68e2adff612 Removing intermediate container e68e2adff612 ---> 90c69ac9cd81 Successfully built 90c69ac9cd81 Successfully tagged mycentos:v1 # 启动容器 $ docker run mycentos:v1 container starting ！！！ echo container starting... ## 结论 # 1、构建的时候只会执行 RUN # 2、在启动容器的时候才会执行 CMD、ENTRYPOINT- RUN、CMD、ENTRYPOINT 多条执行对比
====================================== # 第二个 RUN、CMD、ENTRYPOINT 多条执行对比 ====================================== FROM centos:7 RUN echo "images building1!" RUN echo "images building2!" CMD ["echo","container1","starting..."] CMD ["echo","container2","starting..."] ENTRYPOINT ["echo","container1","starting ！！！"] ENTRYPOINT ["echo","container2","starting ！！！"] # 执行构建 $ docker build -t mycentos:v2 . Sending build context to Docker daemon 3.072kB Step 1/7 : FROM centos:7 ---> b5b4d78bc90c Step 2/7 : RUN echo "images building1!" ---> Running in df4a71aa2294 images building1! Removing intermediate container df4a71aa2294 ---> 5cd5fa848fcc Step 3/7 : RUN echo "images building2!" ---> Running in 866f13acff03 images building2! ............. Successfully built 80392cab445b Successfully tagged mycentos:v2 # 启动容器,查看输出 $ docker run mycentos:v2 container2 starting ！！！ echo container2 starting... ## 结论 # 1、构建的时候只会执行RUN，并且RUN有多条命令会依次执行 # 2、在启动容器的时候才会执行CMD、ENTRYPOINT，并且只会执行自己命令的最后一条。- CMD、ENTRYPOINT 命令对比
================================= # 第三个 CMD、ENTRYPOINT 执行对比 ================================= FROM centos:7 CMD ["-ef"] ENTRYPOINT ["ps"] # 执行构建 $ docker build -t mycentos:v3 . # 容器启动后会自动执行ps -ef $ docker run mycentos:v3 UID PID PPID C STIME TTY TIME CMD root 1 0 1 15:46 ? 00:00:00 ps -ef # 容器启动追加参数后会自动执行ps aux $ docker run mycentos:v3 aux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.0 0.0 49632 1540 ? Rs 15:54 0:00 ps aux ## 结论： # 1.CMD与ENTRYPOINT执行顺序，ENTRYPOINT永远执行在CMD之前 # 2.CMD参数是可以在容器启动时追加bash命令覆盖，而ENTRYPOINT不会 -
DockerFile文件Demo
# This dockerfile demo for project build to docker images
# VERSION 2
# Author: Liusx
# Command format: Instruction [arguments / command] …
# 2018/10/10- firstversion: xiao
# 2018/10/11- chanege the tomcat version
# 第一行必须指定基础容器，建议使用aipln类型的小容器
FROM tomcat:8
# 维护者信息(可选)
MAINTAINER liusx liusx@qq.com
# LABEL (可选) qq.com标签信息(自定义信息,多标签放一行)
LABEL app.maintainer=xiaojianjun
LABEL app.version="1.0" app.host='bestxiao.cn' description="这个app产品构建"
# ENV (可选)环境变量(指定一个环境变量，会被后续 RUN 指令使用，并在容器运行时保持
ENV JAVA_HOME /opt/java_jdk/bin
ENV PG_VERSION 9.3.4
ENV PATH /usr/local/postgres-$PG_MAJOR/bin:$PATH
# USER (可选) 指定运行容器时的用户名或 UID，后续的 RUN 也会使用指定用户,前面的RUN 不受影响
# RUN groupadd -r postgres && useradd -r -g postgres postgres
USER postgres
# WORKDIT 后续的 RUN、CMD、ENTRYPOINT 指令配置容器内的工作目录
WORKDIR /path/to/workdir
# ADD/COPY 将外部文件copy到容器中。区别是ADD可以使用URL，还可以是tar
# COPY只能使用dockerfile所在目录
# ADD <src> <dest>
# COPY <src> <dest>
COPY target/tomcat-release.war /usr/local/tomcat/webapps/
# RUN 镜像的操作指令
# RUN <command> [“executable”, “param1”, “param2”]。
RUN echo “deb http://archive.ubuntu.com/ubuntu/ raring main universe” >> /etc/apt/sources.list
RUN apt-get update && apt-get install -y nginx
RUN mkdir /opt/deploy/
RUN echo “\ndaemon off;” >> /etc/nginx/nginx.conf
# EXPOSE 容器启动后需要暴露的端口
EXPOSE 22 80 8443 8080
# VOLUME 本地或其他容器挂载的挂载点，一般用来存放数据库和需要保持的数据等。
#VOLUME ["/data"]
VOLUME ["/data/postgres", "/other/path/"]
# ENTRYPOINT 容器启动后执行命令，不会被docker run提供的参数覆盖，只能有一个ENTRYPOINT,
# 多个ENTRYPOINT，以最后一个为准
#ENTRYPOINT [“executable”, “param1”, “param2”]
#ENTRYPOINT command param param2
ENTRYPOINT echo "helloDocker"
# 容器启动时执行指令,每个 Dockerfile 只能有一条 CMD 命令
#CMD [“executable”, “param1”, “param2”] 使用 exec 执行，推荐方式。
#CMD command param1 param2 在 /bin/sh 中执行，提供给需要交互的应用。
#CMD [“param1”, “param2”] 提供给 ENTRYPOINT 的默认参数。
CMD /usr/sbin/nginx
# ONBUILD 配置当所创建的镜像作为其他新创建镜像的基础镜像时，所执行的操作指令。例如，Dockerfile 使用如下的内容创建了镜像 image-A。-- 很少使用
# ONBUILD ADD . /app/src
# ONBUILD RUN /usr/local/bin/python-build –dir /app/src
3.3.DockerFile构建Java
简介：Dockerfile构建java环境
- 下载安装JDK和Tomcat安装包：
JDK官网下载地址：jdk-8u211-linux-x64.tar.gz
https://www.oracle.com/java/technologies/javase/javase8u211-later-archive-downloads.html
# apache-tomcat-8.5.35.tar.gz下载：
$ wget -P /home https://mirror.bit.edu.cn/apache/tomcat/tomcat-8/v8.5.57/bin/apache-tomcat-8.5.57.tar.gz
- 本地宿主机配置jdk：vi /etc/profile
export JAVA_HOME=/usr/local/jdk
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
- 生效配置source /etc/profile
- 检验版本：java -version
- 编写dockerfile：
FROM centos:7
# 复制并解压JDK文件，然后移动到指定目录
ADD jdk-8u211-linux-x64.tar.gz /usr/local
RUN mv /usr/local/jdk1.8.0_211 /usr/local/jdk
# 配置JDK环境变量
ENV JAVA_HOME=/usr/local/jdk
ENV JRE_HOME=$JAVA_HOME/jre
ENV CLASSPATH=$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
ENV PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH
# 复制并解压tomcat文件，然后移动到指定目录
ADD apache-tomcat-8.5.57.tar.gz /usr/local
RUN mv /usr/local/apache-tomcat-8.5.57 /usr/local/tomcat
# 暴露出需要的端口，暴露的端口可以在容器启动时映射出去
EXPOSE 8080
# 执行命令启动tomcat
ENTRYPOINT ["/usr/local/tomcat/bin/catalina.sh","run"]
- 构建dockerfile并启动容器
docker build -t mycentos:jdk .
docker run -itd -p 80:8080 -v /root/test/ROOT:/usr/local/tomcat/webapps/ROOT mycentos:jdk /bin/bash
3.4.DockerFile构建Nginx
简介：Dockerfile构建Nginx：
- 下载Nginx安装包：
# 下载redis
$ wget -P /home http://nginx.org/download/nginx-1.16.0.tar.gz
- 编写dockerfile：
FROM centos:7
# 拷贝并解压nginx文件
ADD nginx-1.16.0.tar.gz /usr/local
# 拷贝nginx安装的shell脚本
COPY nginx_install.sh /usr/local
# 执行shell脚本安装nginx
RUN sh /usr/local/nginx_install.sh
EXPOSE 80
- 安装nginx的shell脚本：
#!/bin/bash
yum install -y gcc gcc-c++ make pcre pcre-devel zlib zlib-devel
cd /usr/local/nginx-1.16.0
./configure --prefix=/usr/local/nginx && make && make install
- 制作启动Nginx镜像：
# 构建Nginx镜像
docker build -t mycentos:nginx .
# 该方式启动容器后，当退出容器后nginx也会关闭
docker run -itd -p 80:80 mycentos:nginx /usr/local/nginx/sbin/nginx -g
# 使用前台方式永久运行
docker run -itd -p 80:80 mycentos:nginx /usr/local/nginx/sbin/nginx -g "daemon off;"
- Nginx镜像启动注意：
- 容器里nginx是以daemon方式启动，退出容器时 nginx 也会随着停止：/usr/local/nginx/sbin/nginx
- 使用前台方式永久运行：/usr/local/nginx/sbin/nginx -g "daemon off;"
3.5.DockerFile构建Redis
简介：Dockerfile构建redis
- 下载Redis安装包：
# 下载redis
$ wget -P /home http://download.redis.io/releases/redis-4.0.9.tar.gz
- 编写redis编译安装shell脚本redis_install.sh
#!/bin/bash
yum install -y gcc gcc-c++ make openssl openssl-devel
cd /home/redis-4.0.9
make && make PREFIX=/usr/local/redis install
mkdir -p /usr/local/redis/conf/
cp /home/redis-4.0.9/redis.conf /usr/local/redis/conf/
sed -i '69s/127.0.0.1/0.0.0.0/' /usr/local/redis/conf/redis.conf
sed -i '88s/protected-mode yes/protected-mode no/' /usr/local/redis/conf/redis.conf
- 编写Dockerfile
FROM centos:7
ADD redis-4.0.9.tar.gz /home
COPY redis_install.sh /home
RUN sh /home/redis_install.sh
ENTRYPOINT /usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf
- 测试redis：
# 制作镜像
$ docker build -t mycentos:redis .
# 启动容器,6380是宿主机端口，6379是容器的端口
$ docker run -itd -p 6380:6379 mycentos:redis
# 进入容器
$ docker exec -it 9b402baeaba7 /bin/bash
# 宿主机连接redis验证
$ /usr/local/redis/bin/redis-cli -p 6380
127.0.0.1:6380> set name xdclass
OK
127.0.0.1:6380> get name
"xdclass"
127.0.0.1:6380>
3.6.DockerFile构建MySQL
简介：Dockerfile快速部署mysql数据库并初始化
- 方式一：Docker run（参考：https://hub.docker.com/_/mysql）
# 下载mysql5.7的镜像：
docker pull mysql:5.7
# 启动命令：
docker run --name mysql-5.7 -p 3307:3306 -e MYSQL_ROOT_PASSWORD=password -d mysql:5.7
# 进入容器命令：
docker exec -it 4336ae28fbfa env LANG=C.UTF-8 /bin/bash
- 方式二：Dockerfile
FROM mysql:5.7
WORKDIR /docker-entrypoint-initdb.d
ENV LANG=C.UTF-8
# 只能用ADD，不能用COPY。用ADD命令会执行init.sql，用COPY是不用执行init.sql
ADD init.sql .
- 初始化sql文件—init.sql：
-- 建库
create database `db_student`;
SET character_set_client = utf8;
use db_student;
-- 建表
drop table if exists `user`;
CREATE TABLE user (
id tinyint(5) zerofill auto_increment not null comment '学生学号',
name varchar(20) default null comment '学生姓名',
age tinyint default null comment '学生年龄',
class varchar(20) default null comment '学生班级',
sex char(5) not null comment '学生性别',
unique key (id)
)engine=innodb charset=utf8;
-- 插入数据
insert into user values('1','小明','15','初三','男');
insert into user values('2','小红','13','初二','女');
insert into user values('3','小东','14','初一','男');
insert into user values('4','小西','12','初二','男');
- 构建并启动容器：
# 构建镜像
docker build -t my-mysql:5.7 .
# 启动容器：
docker run --name some-mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=abc123456 -d my-mysql:5.7
# 进入容器：
docker exec -it 4336ae28fbfa /bin/bash
Docker网络
1.Docker网络模式介绍
简介：介绍Docker网络模式
-
默认的三种网络模式：
-
- bridge：桥接模式（默认）
- host：主机模式
- none：无网络模式
$ docker network ls
NETWORK ID NAME DRIVER SCOPE
556415881e39 bridge bridge local
52b4ea8557e8 host host local
97afac35cd87 none null local
2.Docker0网络模式
简介：介绍Docker桥接网络模式（bridge）
- 桥接模式是docker 的默认网络设置，当Docker服务启动时，会在主机上创建一个名为docker0的虚拟网桥，并选择一个和宿主机不同的IP地址和子网分配给docker0网桥
- 我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！
- 桥接拓扑图：
# 安装工具（宿主机）：查看网络模式详情
$ yum install -y net-tools
$ yum install -y bridge-utils
$ route -n
Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
0.0.0.0 172.18.0.1 0.0.0.0 UG 0 0 0 eth0
172.18.0.0 0.0.0.0 255.255.0.0 U 0 0 0 eth0
$ brctl show
bridge name bridge id STP enabled interfaces
docker0 8000.024251f1889c no veth3185551
vethff4dcf7
vethf35dc45
# 我们直接启动的命令 --net bridge,而这个就是我们得docker0
# bridge就是docker0
$ docker run -d -P --name tomcat01 tomcat
等价于 =>
$ docker run -d -P --name tomcat01 --network bridge tomcat
# 备注：
# 默认bridge启动的容器可以用ip与宿主机连通（ping通）
# 也可以和同类bridge网络模式的容器用ip连通（ping通）
# 当时不可以用容器名称来ping通。如果想通过容器名连通，那么必须使用--link或自定义网络模式
简介：介绍Docker主机网络模式（host）
- host 模式：该模式下容器是不会拥有自己的ip地址，而是使用宿主机的ip地址和端口。
# 启动nginx容器命令并防火墙放开80端口
#--net=host，该参数为指定host模式，不需要指定端口：
$ docker run -itd --net=host centos:nginx /usr/local/nginx/sbin/nginx -g "daemon off;"
$ firewall-cmd --zone=public --add-port=80/tcp --permanent
$ firewall-cmd --reload
简介：介绍Docker关闭网络模式介绍（none）
- none模式：关闭模式
- 无法连外网
$ docker run -itd --net=none centos:7
思考一个场景：我们编写了一个微服务，database url=ip: 项目不重启，数据ip换了，我们希望可以处理这个问题，可以通过名字来进行访问容器？
主要解决方案以下两种：
- Link单项通信
- 自定义网络模式
3.Link实现单向通信
简介：介绍基于link单向通信
# 启动mysql数据库容器：
$ docker run --name mydb -e MYSQL_ROOT_PASSWORD=password -d mysql:5.7
# 启动Tomcat应用容器并link到mysql数据库（模拟两个Tomcat）：
$ docker run -itd --name tomcat1 --link mydb tomcat:7
$ docker run -itd --name tomcat2 --link mydb tomcat:7
# 测试tomcat1 和 tomcat2容器 ping mydb容器，是可以ping通
$ docker exec -it tomcat1 ping mydb
PING mydb (172.18.0.3) 56(84) bytes of data.
64 bytes from mydb (172.18.0.3): icmp_seq=1 ttl=64 time=0.062 ms
$ docker exec -it tomcat2 ping mydb
PING mydb (172.18.0.3) 56(84) bytes of data.
64 bytes from mydb (172.18.0.3): icmp_seq=1 ttl=64 time=0.064 ms
# 反过来mydb容器 ping tomcat1和tomcat2 无法ping通
# 注意：mydb 这个容器一定要存在！
# 官方版的mysql 5.7 需要安装工具才有ping命令（mysql不是基于centos镜像构建的）：
$ apt-get update && apt-get install iputils-ping
结论：
# 结论
1.进入tomcat1或tomcat2容器 ping => mysql容器（可ping通）
2.反过来mysql容器 ping 容器 tomcat1或tomcat2（无法ping通）
3.–-link xxx：本质就是在自己的hosts配置中添加映射
4.这种方式已经不推荐使用了，可以使用自定义网络
4.Docker自定义网络模式
docker network --help
connect -- 将容器连接（添加）到网络，对应disconnect
create -- 创建一个新网络，名称由自己取
disconnect -- 将容器移除网络，对应connect
inspect -- 显示网络上的详细信息
ls -- 列出用户创建的所有网络
prune -- 删除所有未使用的网络
rm -- 删除一个或多个网络
查看所有的docker网络
$ docker network ls
NETWORK ID NAME DRIVER SCOPE
556415881e39 bridge bridge local
52b4ea8557e8 host host local
97afac35cd87 none null local
# 创建一个新的网桥：
# -d,--driver：创建的自定义网络的模式，不输入默认创建也是bridge模式
# --subnet 192.168.0.0/16：为网络确定ip范围
# --gateway 192.168.0.1：确定网关
$ docker network create -d bridge mynet
#############
### 方式一 ###
#############
# 启动tomcat01和tomcat02，并加入mynet网络中。
$ docker run -itd --name tomcat01 --network mynet tomcat:7
$ docker run -itd --name tomcat02 --network mynet tomcat:7
# 最后分别进入俩个容器中进行验证：(成功ping通)
$ docker exec -it tomcat01 ping tomcat02
$ docker exec -it tomcat02 ping tomcat01
# 把容器移除网桥：
$ docker network disconnect mynet tomcat01 tomcat02
#############
### 方式二 ###
#############
# 启动tomcat03和tomcat04容器：
$ docker run -itd --name tomcat03 tomcat:7
$ docker run -itd --name tomcat04 tomcat:7
# 把tomcat03和tomcat04容器加入mynet网桥：
$ docker network connect mynet tomcat03
$ docker network connect mynet tomcat04
# 最后分别进入俩个容器中进行验证：(成功ping通)
$ docker exec -it tomcat01 ping tomcat02
$ docker exec -it tomcat02 ping tomcat01
# 把容器移除网桥：
$ docker network disconnect mynet tomcat03 tomcat04
# 假如现在有2个自定义网络；myredis、mydb
# myredis：有 myredis01 容器和 myredis02 容器.
# mydb：有 mysql01 容器和 mysql02 容器.
# 现在想要 myredis01 能与 mysql01 和 mysql02 容器连通。
# 可以把 myredis01 加入 mydb网络中即可：
$ docker network connect mydb myredis01
5.Docker容器特权模式
# 启动并进入一个普通的容器：
$ docker run -it --name mycentos centos:7 /bin/bash
# 安装网络工具：
$ yum -y install net-tools
# 查看路由执行：
$ route -n
# 删除网关（失败）：
$ route del default gw 172.17.0.1
# 启动拥有特权模式的容器：
# --privileged=true
$ docker run -it --privileged=true --name mycentos1 centos:7 /bin/bash
# 删除网关：
$ route del default gw 172.17.0.1
# 备注：特权模式用的比较少
Docker-Compose
1.Docker-Compose安装
简介：Compose的介绍
- docker-compose：是一个用于定义和运行多容器 Docker 的应用程序工具，可以帮助我们可以轻松、高效的管理容器
- docker-compose安装（两种方式）：
- 方式一：curl方法（二进制文件直接安装）
sudo curl -L "https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# 上面下载比较慢，如果下载失败就用此命令，阿里镜像
sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.26.2/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
docker-compose --version
- 方式二：pip方法
# 1.安装pip工具
# yum install -y epel-release python-pip
$ yum install -y epel-release
$ yum install -y python-pip
# 确认版本,更新pip --一般情况可以省略该步骤,如不成功会提示更新
$ pip --version
$ pip install --upgrade pip
# 2.安装docker-compose,-i 是镜像加速的
$ pip install docker-compose==1.24.1 -i https://pypi.tuna.tsinghua.edu.cn/simple
# 3.查看docker-compose版本：
$ docker-compose version
# 卸载docker-compose命令
$ pip uninstall docker-compose
- 安装pip报错解决：
[root@localhost yum.repos.d]# yum install python-pip -y
已加载插件：fastestmirror
One of the configured repositories failed (未知),
and yum doesn't have enough cached data to continue. At this point the only
safe thing yum can do is fail. There are a few ways to work "fix" this:
1. Contact the upstream for the repository and get them to fix the problem.
2. Reconfigure the baseurl/etc. for the repository, to point to a working
upstream. This is most often useful if you are using a newer
distribution release than is supported by the repository (and the
packages for the previous distribution release still work).
3. Disable the repository, so yum won't use it by default. Yum will then
just ignore the repository until you permanently enable it again or use
--enablerepo for temporary usage:
yum-config-manager --disable <repoid>
4. Configure the failing repository to be skipped, if it is unavailable.
Note that yum will try to contact the repo. when it runs most commands,
so will have to try and fail each time (and thus. yum will be be much
slower). If it is a very temporary problem though, this is often a nice
compromise:
yum-config-manager --save --setopt=<repoid>.skip_if_unavailable=true
Cannot retrieve metalink for repository: epel/x86_64. Please verify its path and
try again
解决：
# 修改配置文件，对【epel】中注释掉metalink ，取消注释 baseurl
vi /etc/yum.repos.d/epel.repo
- docker-compose卸载的2种方式
# curl方式安装的话
sudo rm /usr/local/bin/docker-compose
# pip方式方式安装的话
pip uninstall docker-compose
- docker-compose命令补齐：
# 下载最新版本
sudo curl -L https://raw.githubusercontent.com/docker/compose/$(docker-compose version --short)/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
# 下载指定版本
sudo curl -L https://raw.githubusercontent.com/docker/compose/1.26.2/contrib/completion/bash/docker-compose -o /etc/bash_completion.d/docker-compose
# 刷新配置
source /etc/bash_completion.d/docker-compose
2.Docker-Compose快速上手
# 编写一个最最简单的yml也可以是yaml：
$ mkdir -p /home/docker-compose/test
$ cd /home/docker-compose/test
$ vi docker-compose.yml
# 编辑保存以下内容
version: '3'
services:
redis: #服务名称
image: redis
# 然后保存文件（格式一定要注意，该空格要空格，冒号后面必须有空格）
docker-compose操作容器（一定要进入配置文件目录）
常用选项：
--verbose：输出更多的调试信息
--version：查看compose的版本
-f --file FILE：使用特定的compose模板文件，默认为docker-compose.yml。
-p --project-name NAME 指定项目名称，默认使用目录名称。
==================================================================================
docker-compose up 前台启动容器
docker-compose up -d 后台启动容器
docker-compose -f docker-compose.yml up 指定yml文件启动,-f 指定yml文件
docker-compose down 停止并删除容器
docker-compose down --volumes 停止并删除容器并删除volume
docker-compose ps 查看容器运行情况
docker-compose ps -a 查看容器所有情况
docker-compose start 启动容器，如想执行单个容器追加容器名称即可
docker-compose stop 停止容器，如想执行单个容器追加容器名称即可(这种停止容器不会删除容器)
docker-compose restart 重启容器，如想执行单个容器追加容器名称即可
docker-compose pause 暂停容器，如想执行单个容器追加容器名称即可
docker-compose unpause 恢复容器，如想执行单个容器追加容器名称即可
docker-compose rm nginx 删除容器（删除前必须关闭nginx容器）
docker-compose images 查看镜像
docker-compose exec {service_name} {bash} 进入某个容器
docker-compose exec redis bash 进入redis容器
docker-compose logs -tf nginx 查看nginx的实时日志
docker-compose build nginx 构建镜像
docker-compose build --no-cache nginx 不带缓存的构建。
docker-compose config -q 验证yml文件配置，配置正确不输出任何内容，配置错误，输出错误信息
docker-compose events --json nginx 以json的形式输出nginx的docker日志
==================================================================================
- docker-compose中YAML常用的字段：
build
dockerfile 指定dockerfile文件名
context 构建镜像上下文路径
args: args是一些提供的参数
- buildno=1
- user=someuser
image 指定镜像
command 执行命令，覆盖默认命令
container_name 指定容器名称，由于容器名称是唯一的，如果指定自定义名称，则无法scale
deploy 指定部署和运行服务相关配置，只能在Swarm模式使用
environment 添加环境变量
networks 加入网络，引用顶级networks下条目
ports 暴漏端口，与-p相同，但端口不能低于60
volumes 挂载宿主机路径或命名卷在顶级volumes定义卷名称
restart 重启策略，默认no，always|on-failurel|unless-stopped
hostname 容器主机名
depends_on 依赖某个或多个容器
- mysql 依赖的容器名称，mysql容器最先启动
- redis 依赖的容器名称，redis容器其次启动，最后启动本身的容器
注意：操作docker-compose一定要在配置文件docker-compose.yml文件路径下操作
3.Docker-Compose核心技能
简介：Compose核心实用技能掌握
docker-compose.yml：由三大部分组成：
- version：yml版本
- services：docker容器服务。里面可以多个docker容器
- networks：网络模式
最关键是services和networks两个部分。
compose设置网络模式、compose使用端口映射、compose设置文件共享、compose管理多个容器
$ mkdir -p /home/docker-compose/test1
$ cd /home/docker-compose/test1
$ vi docker-compose.yml
version: '3' # yml的版本，不是compose的版本
services:
nginx: # 服务名称，用户自定义
image: mycentos:nginx # 可以是本地的的image，如果本地没有回去Docker Hub上下载
network_mode: "host" # compose设置网络模式
volumes: # compose设置文件共享
- /home:/usr/local/nginx/html
- /var/logs/nginx/logs:/usr/local/nginx/logs
command: /usr/local/nginx/sbin/nginx -g "daemon off;"
redis:
image: mycentos:redis # 可以是本地的的image，如果本地没有回去Docker Hub上下载
ports: # compose使用端口映射
- "6380:6379"
# 后台启动容器：
$ docker-compose up -d
# 查看容器运行情况：
$ docker-compose ps
4.Docker-Compose搭建博客
简介：Compose快速搭建个人博客wordpress
$ mkdir -p /home/docker-compose/wordperss
$ cd /home/docker-compose/wordperss
$ vi docker-compose.yml
version: '3.3'
services:
db:
image: mysql:5.7
volumes:
- db_data:/var/lib/mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: somewordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress
wordpress:
depends_on:
- db
image: wordpress:latest
ports:
- "8000:80"
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: wordpress
WORDPRESS_DB_NAME: wordpress
volumes:
db_data: {}
# 启动wordpress：
$ docker-compose up -d
# 打开浏览器访问：IP:8000
# 在浏览器进行安装配置
# 将删除容器和默认网络，但会保留WordPress数据库：
$ docker-compose down
# 将删除容器，默认删除网络和WordPress数据库：
$ docker-compose down --volumes
5.Docker-Compose详细分析
简介：分析上节docker-compose.yml
version: '3.3'
services:
db:
image: mysql:5.7 #docker run -itd mysql:5.7
volumes:
- db_data:/var/lib/mysql #采用的是卷标的形式挂载（注意：- db_data是参数，可以变，自 定义，必须与下面对应）
restart: always #自动重启，保证服务在线
environment:
MYSQL_ROOT_PASSWORD: somewordpress #指定环境变量 docker -itd -e MYSQL_ROOT_PASSWORD= somewordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress
wordpress:
depends_on:
- db # - db 是参数，合起来的意思是只有当上面的mysql数据库安装成功后，这个wordpress才可 以被安装，还有一个功能，就是docker --link 将上面的mysql数据库，与这个wordpress应用连起来
image: wordpress:latest
ports:
- "8000:80"
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: wordpress
WORDPRESS_DB_NAME: wordpress
volumes:
db_data: {}
- docker-compose中有两种方式可以设置volumes
- 使用具体路径直接挂载到本地，特点就是直观
- 使用卷标的形式，特点就是简洁，但是不知道数据到底在本地的什么位置。需要通过卷标查看
- docker volume ls
- docker volume inspect wordpress_db_data
Docker核心镜像仓库实战
1.Docker镜像仓库介绍
简介：讲解一般公司中docker仓库的使用
-
什么是镜像仓库？：存放着很多镜像的仓库
-
为什么要使用镜像仓库？ ：1.起到备份作用，2.方便其他机器下载使用
-
镜像仓库的种类？我们可以大致分为两大类：
-
-
公共镜像仓库
-
- 官方：https://hub.docker.com/，基于各个软件开发或者有软件提供商开发的
- 非官方：其他组织或者公司开发的镜像，供大家免费使用。比如阿里云
-
私有镜像仓库 公司自己搭建的，用于存放公司内部的镜像，自己管理，不提供给外部使用，避免了商业项目暴露出 去的风险。
-
2.阿里云镜像仓库的搭建与使用
阿里云镜像仓库申请地址：
进入阿里云自己创建镜像仓库（创建镜像仓库时会让你创建命名空间，按步骤走就可以了）：
点击管理按钮有教程指南
- 步骤：
# 1.登录阿里云Docker Registry
$ sudo docker login --username=xxx registry.cn-shanghai.aliyuncs.com
# 2.将镜像推送到Registry
$ sudo docker login --username=xxx registry.cn-shanghai.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shanghai.aliyuncs.com/liuxx/test:[镜像版本号]
$ sudo docker push registry.cn-shanghai.aliyuncs.com/liuxx/test:[镜像版本号]
# 3.从Registry中拉取镜像
$ sudo docker pull registry.cn-shanghai.aliyuncs.com/liuxx/test:[镜像版本号]
3.Harbor私服仓库搭建与使用
构建自己的镜像仓库
安装前确保前置条件是否满足：需要安装docker、docker-compose、openssl以及python2.7以上
版本下载地址：https://github.com/goharbor/harbor/releases
- 离线版本安装：offline（本次使用离线下载）
- 在线版本安装：online
- 教程：https://www.cnblogs.com/zhzhlong/p/12898834.html、https://www.cnblogs.com/pangguoping/p/7650014.html
# 安装
$ yum -y install openssl
# Harbor离线版安装下载地址 ：https://github.com/goharbor/harbor/releases
# wget https://github.com/goharbor/harbor/releases/download/v1.10.1/harbor-offline-installer-v1.9.3.tgz
# 由于国外下载特别慢，已经以前准备好，上传对应安装包并解压：
$ mkdir -p /home/harbor/ && cd /home/harbor/
$ tar -xzvf /home/harbor-offline-installer-v1.9.3.tgz -C /home/harbor/
# 修改配置：
$ vi harbor.yml
# 修改配置文件
hostname: 192.168.0.151 # 修改主机名（注意空格）
harbor_admin_password: password # 修改密码（注意空格）
# 执行脚本（生成docker-compose.yml文件）：
$ sh prepare
# 执行安装命令（启动docker-compose）：
$ sh install.sh
# 执行命令：
$ docker-compose ps
# 访问Harbor，url为本机地址，默认用户名admin/password
# 关闭、启动
$ docker-compose down
$ docker-compose up -d
配置与使用Harbor仓库
$ docker login --username admin 192.168.3.54
Password:
Error response from daemon: Get https://192.168.3.54/v2/: dial tcp 192.168.3.54:443: connect: connection refused
-
Docker配置使用自建仓库
-
- 默认docker只允许访问 https仓库
- 如果要访问 http 仓库需要自己配置
-
配置允许访问http仓库（追加记得加逗号）：
$ vi /etc/docker/daemon.json
{
"registry-mirrors": ["https://a32yzw3z.mirror.aliyuncs.com"],
"insecure-registries":["http://192.168.3.44"]
}
# 重启docker服务：
$ systemctl restart docker.service
# 启动docker-compose(重启docker务必记得要重启docker-compose)：
$ docker-compose up -d
# 网页上创建项目名.见下图
# 登录：
$ docker login --username=admin 192.168.3.54
# 改名打tag：
$ docker tag SOURCE_IMAGE[:TAG] 192.168.3.54/test/IMAGE[:TAG]
$ docker tag mysql:5.7 192.168.3.54/test/mysql:5.7
# 推送：
$ docker push 192.168.3.54/test/IMAGE[:TAG]
$ docker push 192.168.3.54/test/mysql:5.7
# 下载：
$ docker pull 192.168.0.151/xdclass/mysql:5.7
# 备注：
$ docker login 后有一个登录凭证（可删除，下次需要密码）：
# 建议从安全角度出发，每次登录后进行删除）
$ rm /root/.docker/config.json
# 提示中有告诉我们密码存在/root/.docker/config.json 文件中
$ docker login --username=admin 192.168.3.54
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
网页上创建项目名：
