一、安装

要求

centos7

uname -r

cat /etc/redhat-release

cat /etc/os-release

lsb_release -a

c/c++

yum -y install gcc

yum -y install gcc-c++

下载

卸载

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2
/*
   sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
*/

#阿里云镜像    
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

yum makecache fast 更新yum软件包索引

#安装docker相关
yum install -y docker-ce docker-ce-cli containerd.io

启动

docker version

sudo systemctl start docker

# 自启动
systemctl enable docker

docker run hello-world

配置镜像加速

mkdir -p /etc/docker
# 好像这个快点
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://st53edx2.mirror.aliyuncs.com"]
}
EOF

# 或者
curl -sSL https://get.daocloud.io/daotools/set_mirror.sh | sh -s http://f1361db2.m.daocloud.io

# 该脚本可以将 --registry-mirror 加入到你的 Docker 配置文件 /etc/docker/daemon.json 中。适用于 Ubuntu14.04、Debian、CentOS6 、CentOS7、Fedora、Arch Linux、openSUSE Leap 42.1，其他版本可能有细微不同。更多详情请访问文档。
# /etc/docker/daemon.json 逗号

sudo systemctl daemon-reload

sudo systemctl restart docker

6中： service docker restart

UTOOLS1589771025596.png

Centos6.8

yum install -y epel-release
yum install -y docker-io
安装后的配置文件：/etc/sysconfig/docker
启动Docker后台服务：service docker start
docker version验证

卸载

systemctl stop docker 

yum -y remove docker-ce

yum remove docker-ce docker-ce-cli containerd.io

rm -rf /var/lib/docker

二、介绍

简介

基于Go语言实现的云开源项目，软件可以带环境安装，透过镜像(images)将作业系统核心除外，运作应用程式所需要的系统环境，由下而上打包，达到应用程式跨平台间的无缝接轨运作。

理念

Docker的主要目标是“Build，Ship and Run Any App,Anywhere”

“一次封装，到处运行”，只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作

总结

解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

作用

介绍

Linux 容器，Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

比较

比较了 Docker 和传统虚拟化方式的不同之处：

  • 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
    而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
  • 每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。

一次构建、随处运行

  • 更快速的应用交付和部署

  • 更便捷的升级和扩缩容

  • 更简单的系统运维

  • 更高效的计算资源利用

    • Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。

官网

docker官网：http://www.docker.com

docker中文网站：https://www.docker-cn.com/

Docker Hub官网: https://hub.docker.com/

阿里云镜像：https://dev.aliyun.com/search.html

三、常用命令

image-20200329000057597

UTOOLS1589793855573.png

帮助命令

docker version

docker –help

docker info

镜像命令

docker images

列出本地主机上的镜像

  • -a 列出所有
  • -q 只显示镜像id
  • –digests 显示所有摘要信息
  • –automated 只列出automated build类型的镜像

docker search [ ] 镜像名

网站：https://hub.docker.com

  • –no-trunc ：显示完整镜像描述

  • -s n :列出收藏数不小于n的镜像

  • –automated 只列出automated build类型的镜像

docker pull 镜像名[:tag]

没有tag则latest

[root@aliyun ~]# docker pull mysql
Using default tag: latest
latest: Pulling from library/mysql
afb6ec6fdc1c: Pull complete 
0bdc5971ba40: Pull complete 
97ae94a2c729: Pull complete 
f777521d340e: Pull complete 
1393ff7fc871: Pull complete 
a499b89994d9: Pull complete 
7ebe8eefbafe: Pull complete 
597069368ef1: Pull complete 
ce39a5501878: Pull complete 
7d545bca14bf: Pull complete 
0f5f78cccacb: Pull complete 
623a5dae2b42: Pull complete 
Digest: sha256:beba993cc5720da07129078d13441745c02560a2a0181071143e599ad9c497fa
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest
[root@aliyun ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               latest              94dff5fab37f        2 days ago          541MB
hello-world         latest              bf756fb1ae65        4 months ago        13.3kB
[root@aliyun ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
afb6ec6fdc1c: Already exists 
0bdc5971ba40: Already exists 
97ae94a2c729: Already exists 
f777521d340e: Already exists 
1393ff7fc871: Already exists 
a499b89994d9: Already exists 
7ebe8eefbafe: Already exists 
4eec965ae405: Pull complete 
a531a782d709: Pull complete 
10e94c02b508: Pull complete 
799a94b968ef: Pull complete 
Digest: sha256:5c9fd7949bc0f076429fa2c40d0e7406e095bdb5216a923257b31972a6f3ae4f
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

docker rmi 镜像名字或ID

  • -f 镜像id1 镜像id2 强制删除
  • docker rmi -f $(docker images -qa)

容器命令1

docker run [ ] images [ 命令]

  • –name=”newName”

  • -d 后台运行

  • 如果没有进程交互将会删除

  • -i 交互运行，与t同时用

  • -t 分配伪输入终端

  • -P 大写随机端口映射

  • -p 小写指定端口映射
    ​ hostPort:containerPort 8080:8080

  • –privileged

    最高权限

docker run -it centos /bin/bash

docker ps [option]

  • -a 列出所有正在运行和历史运行的的容器
  • -l 显示最近创建的容器
  • -n 显示最近x个容器
  • -q 只显示容器编号
  • –no-trunc 不截断输出

退出容器

  • exit 停止并退出
  • ctrl + p + q 不停止退出

不停运行

docker run -d centos /bin/sh -c "while true;do echo hello docker;sleep 2;done"

docker start

docker restart ID或名字

docker stop ID或名字

docker kill ID或名字

docker rm 容器ID

  • docker rm -f $(docker ps -aq)
  • docker ps -a -q | xargs docker rm

容器命令2

docker logs

  • -f 跟随最新的日志打印
  • -t 加入时间戳
  • –tail n 显示最后n条

docker logs -tf --tail 10 s2sdesr234

docker top 容器ID

显示容器内运行的进程

docker inspect 容器ID

显示容器内部细节

docker attach 容器ID

直接进入容器启动命令行,正在执行的终端

exec

是在容器中打开新的终端，并且可以启动新的进程

  • docker exec -it ID /bin/bash
  • docker exec ID ls -l

docker save

docker save java > /root/java.tar.gz

docker load

docker load < /home/java.tar.gz

docker pause

myjava

docker unpause

docker unpause myjava

docker cp

docker cp 容器ID:容器内路径 目的主机路径

docker cp 源主机路径 容器ID:容器内路径

拷贝

dockder stats

查看容器的资源使用情况

docker update

docker update mydb --restart=always

其他

限制容器大小

docker run -it -m 300M --memory-swap -1 --name con1 u-stress /bin/bash
# 上面的 docker run 命令中通过 -m 选项限制容器使用的内存上限为 300M。同时设置 memory-swap 值为 -1，它表示容器程序使用内存的受限，而可以使用的 swap 空间使用不受限制(宿主机有多少 swap 容器就可以使用多少)。

取消自动重启

docker update --restart=no my-container

删除

docker container prune # 删除所有退出状态的容器

docker volume prune # 删除未被使用的数据卷

docker image prune # 删除 dangling 或所有未被使用的镜像

删除容器：docker container rm $(docker container ls -a -q)

删除镜像：docker image rm $(docker image ls -a -q)

删除数据卷：docker volume rm $(docker volume ls -q)

删除 network：docker network rm $(docker network ls -q)

四、Docker镜像

简介

UnionFS（联合文件系统）

  • Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

  • 特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

Docker镜像加载原理

  • docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
    bootfs(boot file system)主要包含bootloader和kernel, bootloader主要是引导加载kernel, Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

  • rootfs (root file system) ，在bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

  • 对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

好处

最大的一个好处就是 - 共享资源

比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，
同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

特点

Docker镜像都是只读的
当容器启动时，一个新的可写层被加载到镜像的顶部。
这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

commit

docker commit -m "描述信息" -a="作者" 容器ID 要创建的目标镜像名：[标签名]

五、Docker 容器数据卷

简介

容器的持久化、容器间继承 + 共享数据

docker容器中的数据，同步到本地

数据卷

直接添加

  • docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

  • ro只读只能通过宿主机改变

    • docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名

  • -v /etc/nginx 直接容器内

  • docker inspect 容器ID

    查看是否挂载成功

具名和匿名挂载

# 1.匿明挂载
#-v 容器内路径
docker run -d -P --name nginx01 -v /ect/nginx nginx

    #查看volume的情况
    docker volume ls
    #DRIVER              VOLUME NAME
    #local               #8d9e3c1f9abb1651f5b024c2e5f7523484590496021b793c4bc3491e6df2dffc

#默认放在
/var/lib/docker/volumes/xxx/_da

#2.具名
docker run -d -P --name nginx01 -v /home/test:/ect/nginx nginx
docker inspect name[id]

DockerFile添加

  • VOLUME

  • VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]

    UTOOLS1589784828988.png

  • file构建

    # volume testfile 最好Dockerfile
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,--------success1"
CMD /bin/bash

  • bulid生成镜像

    • docker bulid -f /myfile/testfile -t mingming/centos .

  • 使用-f 后的DockerFile构建镜像

    • 没有-f 默认是该目录下的Dockerfile
    • -t 镜像名称

  • 备注

    Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
    解决办法：在挂载目录后多加一个–privileged=true参数即可

数据卷容器

简介

命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器

volumes-from

docker run -it --name test2 --volumes -from test1 centos

test2共享test1的数据卷，相互拷贝

容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

多个mysql、redis共享数据

docker run -d -p 3344:3306 \
-v /home/mysql/conf:/etc/mysql/conf.d \
-v /home/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root --name mysql01 mysql:5.7

docker run -d -p 3345:3306 \
-e MYSQL_ROOT_PASSWORD=root \
--name mysql02 \
--volumes-from mysql01 mysql:5.7

六、DokerFile解析

介绍

Dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

步骤

  • 编写Dockerfile文件
  • docker build
  • docker run

基础知识

  1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数
  2. 指令按照从上到下，顺序执行
  3. #表示注释
  4. 每条指令都会创建一个新的镜像层，并对镜像进行提交

构建过程

  1. docker从基础镜像运行一个容器
  2. 执行一条指令并对容器作出修改
  3. 执行类似docker commit的操作提交一个新的镜像层
  4. docker再基于刚提交的镜像运行一个新容器
  5. 执行dockerfile中的下一条指令直到所有指令都执行完成
  • Dockerfile是软件的设计图纸
  • Docker镜像是软件的交付品
  • Docker容器则可以认为是软件的运行态。

保留字指令

FROM

父类

MAINTAINER

镜像维护者姓名和邮箱

RUN

容器构建时需要运行的命令

EXPOSE

容器对外暴露的端口

WORKDIR

容器登录默认工作目录

ENV

用来构建镜像过程中设置环境变量

ADD

拷贝宿主机文件进入镜像，并自动处理URL和解压tar压缩包

COPY

类似ADD，拷贝文件和目录到镜像中。
将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置

COPY src dest

COPY [“src”, “dest”]

VOLUME

容器数据卷，用于数据保存和持久化工作

CMD

指定容器启动时运行的命令

Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

ENTRYPOINT

追加

指定一个容器启动时要运行的命令

ENTRYPOINT 的目的和 CMD 一样，都是在指定容器启动程序及参数

ONBUILD

当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

案例

base镜像

Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的

自定义myCentos镜像

  1. 目的

    添加vim编辑器

  2. 编写Dockerfile

    FROM centos
MAINTAINER mingming<284908631@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim

EXPOSE 80

CMD echo $MYPATH
CMD echo "success!!"
CMD /bin/bash
    FROM centos 
MAINTAINER  mingming<284908631@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80
CMD echo $MYPATH
CMD echo "---end-----"
CMD /bin/bash

  1. bulid

    docker build -f Dockerfile -t 新镜像名:tag .

    ……………………………….!!!!!!

  2. run

    docker run -it 新镜像名:tag

  3. history

    docker history 镜像名

CMD/ENTERYPOINT

  • CMD

    • 只会有一个CMD生效

    • FROM centos
CMD ["ls", "-a"]
    • docker build -f docker-file -t cmdtest 
#输出目录文件
-l #无法使用，需要使用 ls -al

  • ENTRERYPOINT

    • 参数会传递给ENTRYPOINT，形成新的命令组合

      FROM centos
RUN yum install -y curl
ENTRYPOINT [ "curl", "-s", "http://ip.cn" ]

      docker run this -i

      X docker run this curl -s http://ip.cn -i

    • 本质： <ENTRYPOINT> "<CMD>"

Tomcat9

FROM         centos
MAINTAINER    zzyy
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.8.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_171
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE  8080
#启动时运行tomcat

#ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
#CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out

docker build -t diytomcat .

七、常用安装

步骤

  • search
  • pull
  • images
  • run
  • stop
  • rmi rm

https://hub.docker.com/_/nginx

#下载
docker pull nginx
docker images
#启动
docker run -d --name nginx01 -p 3344:80 nginx
curl localhost:3344
#停止
docker stop nginx01
#开启
docker start nginx01

安装mysql

docker run -p 12345:3306 \
    --name mysql \
    -v /zzyyuse/mysql/conf:/etc/mysql/conf.d \
    -v /zzyyuse/mysql/logs:/logs \
    -v /zzyyuse/mysql/data:/var/lib/mysql \
    -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6

#命令说明：
#    -p 12345:3306：将主机的12345端口映射到docker容器的3306端口。
#    --name mysql：运行服务名字
#    -v /zzyyuse/mysql/conf:/etc/mysql/conf.d ：将主机/zzyyuse/mysql录下的conf/my.cnf 挂载到容器的 /etc/mysql/conf.d
#    -v /zzyyuse/mysql/logs:/logs：将主机/zzyyuse/mysql目录下的 logs 目录挂载到容器的 /logs。
#    -v /zzyyuse/mysql/data:/var/lib/mysql ：将主机/zzyyuse/mysql目录下的data目录挂载到容器的 /var/lib/mysql 
#    -e MYSQL_ROOT_PASSWORD=123456：初始化 root 用户的密码。
#    -d mysql:5.6 : 后台程序运行mysql5.6

#two
docker pull mysql:5.7
docker images
docker run -d -p 3306:3306 \
-v /mysql/conf:/etc/mysql/conf.d \
-v /home/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root --name mysql mysql:5.7

安装tomcat

#用完就删
docker run -it --rm tomcat:9.0

#下载
docker pull tomcat:9.0

#使用
docker images

#启动
dokcer run -d -p 3344:8080 --name tomcat01 tomcat

#进入容器
docker exec -it tomcaat01 /bin/bash

#1.linux命令少 2.没有webapps

#放ROOT目录
mv webapps.dist/* webapps/

安装elasticsearch

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
#docker status 查看cup状态

#测试是否成功
curl localhost:9200

#修改配置
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

[root@aliyun ~]# curl localhost:9200
&#123;
  "name" : "4591b36e5abf",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "Qx1_DjWHQFy44anYtZZhsw",
  "version" : &#123;
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  &#125;,
  "tagline" : "You Know, for Search"
&#125;

PHP环境

镜像：

https://cr.console.aliyun.com/cn-shenzhen/instances/images?search=php

php

docker pull php:5.6-fpm

docker run --name  myphp-fpm -v ~/nginx/www:/www  -d php:5.6-fpm

#
docker run --name myphp-fpm -d \
    -v ~/nginx/www:/www \
    php:7.1-fpm
docker-php-ext-install pdo pdo_mysql

#pdo
docker run --name myphp-fpm -d \
    -v ~/nginx/www:/www \
    -v ~/php/php.ini:/usr/local/etc/php/php.ini \
    php:7.1-fpm


docker run --name myphp-fpm -d \
    -v ~/nginx/www:/www \
    -v ~/php/php.ini:/usr/local/etc/php/php.ini \
    --net myphp \
    php:7.1-fpm

docker-php-ext-install pdo pdo_mysql

#~/php/php.ini添加
extension=mysqli
extension=pdo_mysql
#restart

#验证码
https://blog.csdn.net/qq_25194685/article/details/90407929
#主机中
#如果之前启用了gd，需要先在php.ini文件中注释掉extension=gd.so并重启容器
docker exec -it <容器ID或容器名称> /bin/bash    #进入php容器
#容器中
#echo "deb http://mirrors.163.com/debian/ stretch main contrib non-free\ndeb http://mirrors.163.com/debian/ stretch-updates main contrib non-free\ndeb http://mirrors.163.com/debian/ stretch-backports main contrib non-free" > /etc/apt/sources.list  #软件源修改为网易镜像站源
apt update  #更新软件源
apt install -y libwebp-dev libjpeg-dev libpng-dev libfreetype6-dev #安装各种库
docker-php-source extract #解压源码
cd /usr/src/php/ext/gd  #gd源码文件夹
docker-php-ext-configure gd --with-webp-dir=/usr/include/webp --with-jpeg-dir=/usr/include --with-png-dir=/usr/include --with-freetype-dir=/usr/include/freetype2   #准备编译
docker-php-ext-install gd   #编译安装
php -m | grep gd
#重启容器

docker login --username=mingyuefusu registry.cn-shenzhen.aliyuncs.com
registry.cn-qingdao.aliyuncs.com
docker pull registry.cn-shenzhen.aliyuncs.com/mingyuefusu/php:[镜像版本号]

nginx

mkdir ~/nginx/conf/conf.d 
#配置nginx配置文件 ~/nginx/conf/conf.d/runoob-test-php.conf 
server {
    listen       80;
    server_name  localhost;

    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm index.php;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    location ~ \.php$ {
        fastcgi_pass   php:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  /www/$fastcgi_script_name;
        include        fastcgi_params;
    }
}
#other
server {
    listen       80;
    server_name  localhost;

    location / {
        root   /usr/share/nginx/html/tpblog/public;
        index  index.html index.htm index.php;
         if (!-e $request_filename) {
                rewrite  ^(.*)$  /index.php?s=$1  last;
                break;
         }
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    location ~ \.php$ {
        root /www/tpblog/public;
        fastcgi_pass   myphp-fpm:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        include        fastcgi_params;
    }
}
#运行nginx
docker run --name php-nginx -p 80:80 -d \
    -v ~/nginx/www:/usr/share/nginx/html:ro \
    -v ~/nginx/conf/conf.d:/etc/nginx/conf.d:ro \
    --link myphp-fpm:php \
    --link mysql \
    nginx
 #--link 容器名:别名
 docker run --name php-nginx -p 80:80 -d \
    -v ~/nginx/www:/usr/share/nginx/html:ro \
    -v ~/nginx/conf/conf.d:/etc/nginx/conf.d:ro \
    --net myphp \
    nginx

文件

#~/nginx/www 目录下创建 index.php

<?php
    phpinfo();
?>

mysql

docker pull mysql:5.7
docker run -itd --name mysql-test -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql

docker pull mysql:5.7

docker images

docker run -d -p 3306:3306 \
-v ~/mysql/conf:/etc/mysql/conf.d \
-v ~/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root --name mysql mysql:5.7

docker run -d -p 3306:3306 \
-v ~/mysql/conf:/etc/mysql/conf.d \
-v ~/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root --name mysql --net myphp mysql:5.7

八、仓库

上传、下载

docker login --username=mingyuefusu registry.cn-hangzhou.aliyuncs.com
#su19
docker pull registry.cn-hangzhou.aliyuncs.com/mingyuefusu/test:[镜像版本号]

docker login --username=mingyuefusu registry.cn-hangzhou.aliyuncs.com

docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/mingyuefusu/test:[镜像版本号]


docker push registry.cn-hangzhou.aliyuncs.com/mingyuefusu/test:[镜像版本号]

#registry.cn-shenzhen.aliyuncs.com/mingyuefusu/test
#1. 登录阿里云Docker Registry

$ sudo docker login --username=mingyuefusu registry.cn-shenzhen.aliyuncs.com

用于登录的用户名为阿里云账号全名，密码为开通服务时设置的密码。

您可以在访问凭证页面修改凭证密码。
#2. 从Registry中拉取镜像

$ sudo docker pull registry.cn-shenzhen.aliyuncs.com/mingyuefusu/tomcat:[镜像版本号]

#3. 将镜像推送到Registry

$ sudo docker login --username=mingyuefusu registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/mingyuefusu/tomcat:[镜像版本号]
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/mingyuefusu/tomcat:[镜像版本号]

九、可视化

portainer

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

UTOOLS1589777338214.png

十、docker网络

基础

每启动一个docker容器，就会给docker容器分配一个ip，安装docker，会有桥接模式的docker0，使用veth-pair

#ip addr

docker run -d -P --name tomcat01 tomcat
#查看容器的内部网络地址
docker exec -it tomcat01 ip addr
#ping容器内部
ping 172.17.0.2

启动容器，多一对网卡

UTOOLS1589799256085.png

255.255.255.255

/16 ：255*255

/24 ：255

UTOOLS1589800136901.png

docker中的网络接口都是虚拟的，转发效率高，内网传递文件

只要容器删除，对应的一对网桥就没了

不建议使用

UTOOLS1589800943301.png

docker run -d -P --name tomcat01 --link tomcat01 tomcat
docker exec -it tomcat03 ping tomcat02
#反向不行

在host中添加映射

docker exec -it tomca03 cat /etc/hosts
123.23.2.2 tomcat02 234df234

network

docker network inspect id

docker inspect id

自定义网络

docker network ls

docker network rm mynet

网络模式

  • bridge： 桥接 （默认）
  • none： 不配置网络
  • host： 和宿主机共享网络
  • container： 容器网络连通（局限，少）
docker run -d -P --name tomcat01 -net bridge tomcat
#默认docker0特点：默认，域名不能访问，--link可以打通
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet #网关一般加一，wifi，网关就是一个网络连接到另一个网络的“关口”
#自己的网络
[root@aliyun ~]# docker network inspect mynet
[root@aliyun ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat 
4cc9bcbeb9181a12945b0d9ba4e9d99e5d5b6150c0ef3bb59e77e3f2218c4567

[root@aliyun ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat 
f95db0c36e29f4063e3c4a04e1864dc3406ed8f6a08e6c83857adbd8d53ccf54

[root@aliyun ~]# docker network inspect mynet 
[
    {
        "Name": "mynet",
        "Id": "b1c61c0c2564f1eb204f5aaee8477d2bc31128310804f7688e00083127e0ce26",
        "Created": "2020-05-18T22:43:43.396147343+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "4cc9bcbeb9181a12945b0d9ba4e9d99e5d5b6150c0ef3bb59e77e3f2218c4567": {
                "Name": "tomcat-net-01",
                "EndpointID": "0e6ed2e1f691fb8ef012a4a5709e692b867038604f5bac5a7038dd50e80c03e1",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            },
            "f95db0c36e29f4063e3c4a04e1864dc3406ed8f6a08e6c83857adbd8d53ccf54": {
                "Name": "tomcat-net-02",
                "EndpointID": "64e390aa4c22b06c029a3708b1b62d15127d8a4ed37ed567e68ad8db407d80db",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

好处：直接通过容器名称连通

[root@aliyun ~]# docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.086 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.065 ms

不同的集群使用不同的网络

redis：192.161.0.0

mysql：192.162.0.0

网络连通

docker network connect

docker network connect mynet tomcat01
#联通之后，tomcat01直接加到mynet网络上
#一个容器两个ip，公网、私网

跨网络，不同网段，使用docker network connect 连通

redis集群

UTOOLS1589817171956.png

# 创建网卡 默认bridge
docker network create redis --subnet 172.38.0.0/16

# 创建六个redis配置
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

#启动redis1
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#启动redis1
docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#启动redis1
docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#启动redis1
docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#启动redis1
docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#启动redis1
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

UTOOLS1589847889750.png

# 进入其中一个
docker exec -it redis-1 /bin/sh

# 创建集群
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1

# 进入集群
redis-cli -c
cluster info
cluster nodes
set a b

十一、docker compose

简介

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Compose 使用的三个步骤：

  • 使用 Dockerfile 定义应用程序的环境。
  • 使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
  • 最后，执行 docker-compose up 命令来启动并运行整个应用程序。

https://www.runoob.com/docker/docker-compose.html

命令

curl -L https://get.daocloud.io/docker/compose/releases/download/v2.1.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

docker-compose --version

docker-compose up [-d后台运行]

docker-compose down

docker-compose help

docker-compose -h # 查看帮助

docker-compose logs [-f] # 跟踪输出

docker-compose.yaml

version: '' #版本
service: #服务
    web:
        # 服务配置
        images
        build
        network
        ...
        服务二: redis

# 其他配置 网络/卷、全局规则
volumes:
networks:
configs:

例子

version: "3"

services:
  vote:
    build: ./vote
    command: python app.py
    volumes:
      - ./vote:/app
    ports:
      - "5000:80"
    networks:
      - front-tier
      - back-tier

  result:
    build: ./result
    command: nodemon server.js
    volumes:
      - ./result:/app
    ports:
      - "5001:80"
      - "5858:5858"
    networks:
      - front-tier
      - back-tier

  worker:
    build:
      context: ./worker
      dockerfile: Dockerfile.j
    networks:
      - back-tier

  redis:
    image: redis:alpine
    container_name: redis
    ports: ["6379"]
    networks:
      - back-tier

  db:
    image: postgres:9.4
    container_name: db
    environment:
      POSTGRES_USER: "postgres"
      POSTGRES_PASSWORD: "postgres"
    volumes:
      - "db-data:/var/lib/postgresql/data"
    networks:
      - back-tier

volumes:
  db-data:

networks:
  front-tier:
  back-tier: