docker从安装到实战看这篇就够了

安装docker社区版(docker-ce) CentOS7环境

官方安装教程地址：https://docs.docker.com/engine/install/centos/

查看当前centos版本及内核版本

cat /etc/redhat-release  ### 查看centos版本
CentOS Linux release 7.7.1908 (Core)
uname -r  ### 查看当前内核版本
3.10.0-514.el7.x86_64 
yum -y update ### 升级内核版本

安装前检查并删除docker的其他版本

 sudo yum remove docker \ ### \是连接符，长命令 一行放不下，用多行来表示。下同
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

可能上面的命令还不能彻底删除，在后面会报Transaction check error错误，可运行下面命令找出残余的docker余党，进行定点删除。

$ yum list installed | grep docker
docker-client.x86_64                2:1.13.1-109.gitcccb291.el7.centos @extras  
docker-common.x86_64                2:1.13.1-109.gitcccb291.el7.centos @extras  

$ yum remove -y docker-client.x86_64
$ yum remove -y docker-common.x86_64

安装gcc

yum -y install gcc
yum -y install gcc-c++

安装需要的软件包

yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

更新yum软件包索引

yum makecache fast

安装docker-ce

yum -y install docker-ce

启动docker

systemctl start docker

查看并测试docker是否安装成功

docker version ### 查看安装的docker版本
docker run hello-world ### 老hello-world

配置镜像加速

mkdir -p /etc/docker ###创建docker配置文件目录，一般在安装时就已经自动创建了，可自行查看
vim /etc/docker/daemon.json ### 配置文件，配置镜像加速
---
 #阿里云
{
  "registry-mirrors": ["https://｛自已的编码｝.mirror.aliyuncs.com"]
}
---
查询步骤
登录阿里云
点击容器镜像服务
点击镜像加速器
复制镜像加速地址

可视化：

在这里插入图片描述

image-20200501163720790

在这里插入图片描述

完成配置

执行 systemctl daemon-reload systemctl restart docker使配置生效

卸载docker

$ systemctl stop docker 
$ yum -y remove docker-ce
$ rm -rf /var/lib/docker

从官方仓库拉取docker镜像

官方仓库地址

https://hub.docker.com/

配图一张

image-20200501174524426

拉取mysql镜像

输入框输入要搜索的镜像名称

在这里插入图片描述

image-20200501174956566

点进去，再点击Tag选择版本

image-20200501175129625

选取自己要的版本，我这里选择5.7版本，不写分号后面的版本号默认下载==latest==版本

在这里插入图片描述

回到终端张贴命令进行下载

$ docker pull mysql:5.7  ###拉取镜像
5.7: Pulling from library/mysql
54fec2fa59d0: Pull complete 
bcc6c6145912: Pull complete 
951c3d959c9d: Pull complete 
05de4d0e206e: Pull complete 
319f0394ef42: Pull complete 
d9185034607b: Pull complete 
013a9c64dadc: Pull complete 
e745b3361626: Pull complete 
03145d87b451: Pull complete 
3991a6b182ee: Pull complete 
62335de06f7d: Pull complete 
Digest: sha256:e821ca8cc7a44d354486f30c6a193ec6b70a4eed8c8362aeede4e9b8d74b8ebb
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
$ docker images ###查看本地镜像
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mysql               5.7                 f965319e89de        3 days ago          448MB

用拉取的镜像创建一个mysql服务

首先我们要创建一个用于存放各种容器的配置目录，我建议单独新建一个目录，用于存放这些容器和本机挂载的文件，挂载的概念后面会详细讲。

$ mkdir ./dockerappconfig ###这个目录专门用于存放各类容器和本机挂载文件的存放
$ cd dockerappconfig ### 进入该目录
$ mkdir dockermysqlconfig ### 创建用于存放mysql的目录
$ cd dockermysqlconfig ### 进入创建的用于存放mysql配置的目录

启动mysql容器应用

$ docker run -d \ ## docker run 命令可以用镜像创建容器应用 -d 表示后台运行
-p 3306:3306 \  ## 端口暴露，前面是宿主机端口，后者是容器内部端口。设置后就可以通过宿主机端口对容器内部服务进行访问。
--name=c1_mysql \ ## 给容器起个名字，不设置docker会自动分配一个名字
-v $PWD/conf:/etc/mysql/conf.d \ ## 将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
-v $PWD/logs:/logs \ ## 前面是宿主机目录执行该命令会自动创建。这个是日志目录
-v $PWD/data:/var/lib/mysql \ ## 将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
-e MYSQL_ROOT_PASSWORD=123456 \ ## 设置mysql的密码
mysql:5.7
---
$ docker run -id \
-p 3306:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.7

$ docker ps # 查看正在运行的docker容器,可以看到已经有一个mysql启动了
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
b2a2c5193244        mysql:5.7           "docker-entrypoint.s…"   14 minutes ago      Up 14 minutes       0.0.0.0:3306->3306/tcp, 33060/tcp   c1_mysql

进入刚才mysql容器的内部

$ docker exec -it c1_mysql /bin/bash ## -i表示交互模式操作容器，-t表示分配一个伪终端， /bin/bash 表示终端类型
$ root@sfd12/# ls -al
total 84
drwxr-xr-x  1 root root 4096 May  1 10:26 .
drwxr-xr-x  1 root root 4096 May  1 10:26 ..
-rwxr-xr-x  1 root root    0 May  1 10:26 .dockerenv
drwxr-xr-x  1 root root 4096 Apr 28 01:53 bin
drwxr-xr-x  2 root root 4096 Feb  1 17:09 boot
drwxr-xr-x  5 root root  340 May  1 10:26 dev
drwxr-xr-x  2 root root 4096 Apr 23 04:14 docker-entrypoint-initdb.d
lrwxrwxrwx  1 root root   34 Apr 28 01:53 entrypoint.sh -> usr/local/bin/docker-entrypoint.sh
drwxr-xr-x  1 root root 4096 May  1 10:26 etc
drwxr-xr-x  2 root root 4096 Feb  1 17:09 home
drwxr-xr-x  1 root root 4096 Apr 23 04:13 lib
drwxr-xr-x  2 root root 4096 Apr 22 00:00 lib64
drwxr-xr-x  2 root root 4096 May  1 10:26 logs
drwxr-xr-x  2 root root 4096 Apr 22 00:00 media
drwxr-xr-x  2 root root 4096 Apr 22 00:00 mnt
drwxr-xr-x  2 root root 4096 Apr 22 00:00 opt
dr-xr-xr-x 92 root root    0 May  1 10:26 proc
drwx------  1 root root 4096 May  1 10:28 root
drwxr-xr-x  1 root root 4096 Apr 28 01:53 run
drwxr-xr-x  2 root root 4096 Apr 22 00:00 sbin
drwxr-xr-x  2 root root 4096 Apr 22 00:00 srv
dr-xr-xr-x 13 root root    0 May  1 10:26 sys
drwxrwxrwt  1 root root 4096 May  1 10:27 tmp
drwxr-xr-x  1 root root 4096 Apr 22 00:00 usr
drwxr-xr-x  1 root root 4096 Apr 22 00:00 var
$ root@sfd12/# mysql -uroot -p123456  ## 登录mysql
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 3
Server version: 5.7.30 MySQL Community Server (GPL)

Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

mysql> exit
Bye

查看docker为我们创建的宿主机目录

$ ll
drwxr-xr-x 2 root              root 4096 5月   1 18:26 conf
drwxr-xr-x 5 systemd-bus-proxy root 4096 5月   1 18:27 data
drwxr-xr-x 2 root              root 4096 5月   1 18:26 logs

上图一张

在这里插入图片描述

创建一个Nginx服务

步骤：拉取Nginx镜像、设置配置文件挂载目录、用镜像启动一个Nginx容器应用。

为了搞清楚容器中的Nginx配置文件关系，我们可以先启动一个不设置配置文件挂载的Nginx。

$ docker run -it --name=temp_nginx nginx:1.17 /bin/bash
$ ls -al
drwxr-xr-x   1 root root 4096 May  1 16:07 .
drwxr-xr-x   1 root root 4096 May  1 16:07 ..
-rwxr-xr-x   1 root root    0 May  1 16:07 .dockerenv
drwxr-xr-x   2 root root 4096 Apr 22 00:00 bin
drwxr-xr-x   2 root root 4096 Feb  1 17:09 boot
drwxr-xr-x   5 root root  360 May  1 16:07 dev
drwxr-xr-x   1 root root 4096 May  1 16:07 etc
drwxr-xr-x   2 root root 4096 Feb  1 17:09 home
drwxr-xr-x   1 root root 4096 Apr 23 13:02 lib
drwxr-xr-x   2 root root 4096 Apr 22 00:00 lib64
drwxr-xr-x   2 root root 4096 Apr 22 00:00 media
drwxr-xr-x   2 root root 4096 Apr 22 00:00 mnt
drwxr-xr-x   2 root root 4096 Apr 22 00:00 opt
dr-xr-xr-x 100 root root    0 May  1 16:07 proc
drwx------   2 root root 4096 Apr 22 00:00 root
drwxr-xr-x   3 root root 4096 Apr 22 00:00 run
drwxr-xr-x   2 root root 4096 Apr 22 00:00 sbin
drwxr-xr-x   2 root root 4096 Apr 22 00:00 srv
dr-xr-xr-x  13 root root    0 May  1 10:52 sys
drwxrwxrwt   1 root root 4096 Apr 23 13:02 tmp
drwxr-xr-x   1 root root 4096 Apr 22 00:00 usr
drwxr-xr-x   1 root root 4096 Apr 22 00:00 var

我们重点关注下面四个目录或文件

$ /etc/nginx/nginx.conf //nginx的默认加载配置文件
$ /var/log/nginx //日志目录
$ /usr/share/nginx/html //首页
$ /etc/nginx/conf.d/default.conf //默认配置

/etc/nginx/nginx.conf


user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

/etc/nginx/conf.d/default.conf

server {
    listen       80;
    server_name  localhost;

    #charset koi8-r;
    #access_log  /var/log/nginx/host.access.log  main;

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

    #error_page  404              /404.html;

    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    # proxy the PHP scripts to Apache listening on 127.0.0.1:80
    #
    #location ~ \.php$ {
    #    proxy_pass   http://127.0.0.1;
    #}

    # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
    #
    #location ~ \.php$ {
    #    root           html;
    #    fastcgi_pass   127.0.0.1:9000;
    #    fastcgi_index  index.php;
    #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
    #    include        fastcgi_params;
    #}

    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny  all;
    #}
}

方便我们后面的管理，我们可以将这四个位置在宿主机上创建目录保存，在宿主机上创建类似下面的目录。

在这里插入图片描述

使用下面的命令将docker容器中的nginx相关文件拷贝到上述目录

docker cp 容器id:/etc/nginx/nginx.conf /path/dockernginxconfig/conf
docker cp 容器id:/etc/nginx/conf.d/default.conf  /path/dockernginxconfig/conf
docker cp 容器id:/usr/share/nginx/html/index.html  /path/dockernginxconfig/html
docker cp 容器id:/usr/share/nginx/html/50x.html  /path/dockernginxconfig/html

删除上面创建的nginx容器

$ docker stop 容器id
$ docker rm 容器id

重新创建nginx容器

$ docker run -d \
-p 80:80 \
--name=c1_nginx \
-v /path/dockernginxconfig/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /path/dockernginxconfig/conf/default.conf:/etc/nginx/conf.d/default.conf \
-v /path/dockernginxconfig/html:/usr/share/nginx/html \
-v /path/dockernginxconfig/logs:/var/log/nginx \
nginx:1.17

一切顺利访问80端口会出现下面的信息

image-20200502005650999

Docker容器数据卷

作用：1、用来持久化容器运行产生的数据，如mysql的数据。2、容器之间进行数据共享。

使用方式

在容器启动的时候通过-v参数加上
通过DockerFile文件添加

### 通过docker命令在启动容器的时候加上

$ docker run -id \
-p 3306:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.7

### 通过DockerFile设置数据卷，通过DockerFile不能实现宿主机和容器之间的挂载，因为不同的主机可能目录存在不一样。只支持在容器中添加数据卷。所以我们先通过DockerFile设置好容器内部的数据卷，然后DockerFile build成镜像。然后用命令启动。

$ # volume test DockerFile
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,--------success1"
CMD /bin/bash
---
$ docker build -f /root/mydockerFile/dockerfile1 -t mycentos .
执行上述的命令，生成容器，如果未指明宿主机和宿主机的路径映射，docker会自动生成一个宿主机的路径用于挂载，用`docker inspect  容器id` 可查看docker为我们生成的宿主机对应目录
---
备注：Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个--privileged=true参数即可

同镜像容器之间数据卷的传递

$ docker run -d --name=dc01 mycentos ## 启动一个容器命名为dc01
$ docker run -d --name=dc02 --volumes-from dc01 mycentos ## 启动第二个容器 --volumes-from用于关联dc01的数据卷
$ docker run -d --name=dc03 --volumes-from dc01 mycentos ## 启动第三个容器
这三个容器之间的数据卷的修改会相互传递、互相影响。某个的修改都会影响到另外两个，即使删除了dc01，在修改dc02的数据依然可以传递到dc03.

数据卷使用的细节：

1、可挂载单个文件也可挂载一个目录

2、挂载的文件或目录可以不存在，没有docker会自动创建

3、默认读写权限是rw可读可写

4、挂载成功后，容器和宿主机对挂载的目录或文件修改会双向共享

5、容器停止运行后，宿主机在容器停止运行期间对挂载的文件或目录进行修改，当容器再次启动后，会马上获取宿主机修改的内容

6、docker run -d -v 宿主机目录或文件:容器目录或文件:ro 镜像名，加了ro后，表示readOnly，这时候容器就只有读取的权限，不能修改内容。只有主机有修改的权限。

DockerFile

DockerFile是什么

DockerFile是用来构建镜像的文件

官方CentOS DockerFile文件

FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20191001"

CMD ["/bin/bash"]

保留字指令

image-20200502112953072

CMD 和 ENTRYPOINT

两者的用途都是指定容器启动时要执行的命令

CMD：DockerFile可以有多个CMD指令，但是只有最后一个生效，前面的CMD指令会不起作用。CMD指令会被docker run 后面的参数进行替换，如执行docker run -d -p 8080:8080 tomcat ls -l命令启动容器，由于加了 ls -l这个指令，会导致DockerFile中启动tomcat的指令失效，导致tomcat启动失败。

image-20200501225859108

ENTRYPOINT: ENTRYPOINT会组合docker run后面的参数，增强命令功能，而不会直接失效。

image-20200502123051662
ADD 和 COPY

用途：两者都可以设置的镜像上下文构建环境的的文件可以是压缩包拷贝到容器内。

ADD: 可以解压tar类型的jar包

COPY：只是单纯的复制文件，不提供解压功能。
DockerFile基础知识

1、每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2、指令按从上到下，顺序执行

3、#表示注释

4、每条指令都会创建新的镜像层，并对镜像进行提交

基础镜像(scratch)

其他镜像大部分都是基于scratch镜像来构建的
官网描述：

This image is most useful in the context of building base images
(such as debian and busybox) or super minimal images (that contain
only a single binary and whatever it requires, such as hello-world).

As of Docker 1.5.0 (specifically, docker/docker#8827), FROM scratch is
a no-op in the Dockerfile, and will not create an extra layer in your
image (so a previously 2-layer image will be a 1-layer image instead).

From https://docs.docker.com/engine/userguide/eng-image/baseimages/:

You can use Docker’s reserved, minimal image, scratch, as a starting
point for building containers. Using the scratch “image” signals to
the build process that you want the next command in the Dockerfile to
be the first filesystem layer in your image.

While scratch appears in Docker’s repository on the hub, you can’t
pull it, run it, or tag any image with the name scratch. Instead, you
can refer to it in your Dockerfile. For example, to create a minimal
container using scratch

最后一段我们看到，明确说明这个镜像虽然在仓库中，但是我们不能拉取，也无法运行这个镜像，也不能自定义镜像名为scratch。但是可以在Dockerfile文件中使用这个镜像去构建其他镜像。

基于CentOS镜像编写我们自己的CentOS DockerFile文件

$ vim myCentOSDockerFile ### 创建一个自定义的CentOS DockerFile文件

文件内容：

FROM centos
MAINTAINER slf

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80
CMD /bin/bash

### 我们给基础的CentOS镜像安装了vim编辑器和net-tools工具，同时暴露了80端口，设置了登录容器的落脚点为/usr/local

使用DockerFile构建镜像

$ docker build -f ./myCentOSDockerFile -t myCentOS:1.0 .

### 命令解释：docker build -f DockerFile的文件路径  -t 镜像的名称 . ### 点表示构建镜像的上下文环境为当前目录，在需要拷贝文件到容器中时用于定位文件的位置。

创建一个自定义的tomcat DockerFile文件，总结这些保留字指令

FROM         centos
MAINTAINER    slf
#把宿主机当前上下文的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镜像

上面我们介绍到了DockerFile可以构建镜像，那么下面我们来介绍一下镜像。

docker镜像是什么

==docker镜像实际上就是一层一层的文件系统组成的，镜像启动的容器使用的是宿主机内核。这就是为什么容器时轻量级的原因，内核共享。==
docker使用的是联合文件系统（UnionFS)

Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。

Union 文件系统是 Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

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

最大的好处是共享资源，其他镜像可以利用一个基础镜像构建自己的镜像而不用再构建已经存在的镜像了。
Docker镜像可读的

可读不可写这种肯定是为了保证安全

当用一个镜像启动一个容器后，一个可写层被加载到镜像的顶部。这一层通常被称为“容器层”，"容器层"之下都是“镜像层”。

Docker镜像构建的两种方式

使用容器构建镜像

命令：$ docker commit -a="作者" -m="提交的描述信息" 容器id  新构建的镜像名:1.1

$ docker commit -a="slf" -m="description infomation" 容器id mytomcat:1.1

使用DockerFile

这个就不用讲了，自己构建dockerFile文件然后运行docker build命令构建镜像

Docker Compose

什么是Docker Compose

简单来说就是编排多个docker应用的，对多docker应用进行管理，包括启动顺序之类的。
安装Docker Compose

# Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
如果因为网络原因无法下载，可尝试下面的国内地址
curl -L https://get.daocloud.io/docker/compose/releases/download/1.24.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version

卸载Docker Compose

# 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose

使用docker compose编排nginx+springboot项目

首先我们要准备一个springboot项目，打成jar包，上传到服务器。然后为这个springboot项目编写DockerFile文件，根据DockerFIle文件构建该springboot项目的镜像，操作如下。

在这里插入图片描述

上面springboot项目的jar包，下面是DockerFile文件。

springboot项目很简单就是写了接口，输出hello_docker.

springboot_demo_dockerfile文件内容

FROM java:8
MAINTAINER slf 
ADD ./docker-springboot-demo-0.0.1-SNAPSHOT.jar springbootapp.jar
CMD java -jar springbootapp.jar

执行镜像构建命令构建springboot项目的docker镜像

$ docker build -f ./springboot_demo_dockerfile -t myspingbootdemo .
下面是构建信息
Sending build context to Docker daemon  17.62MB
Step 1/4 : FROM java:8
 ---> d23bdf5b1b1b
Step 2/4 : MAINTAINER slf 
 ---> Running in b6167106f4f8
Removing intermediate container b6167106f4f8
 ---> dabcebde817c
Step 3/4 : ADD ./docker-springboot-demo-0.0.1-SNAPSHOT.jar springbootapp.jar
 ---> bd4afe649cd5
Step 4/4 : CMD java -jar springbootapp.jar
 ---> Running in 51950eac8269
Removing intermediate container 51950eac8269
 ---> e6107dc5fa7b
Successfully built e6107dc5fa7b
Successfully tagged springbootdemo:1.1

查看镜像是否构建成功

docker images

在这里插入图片描述

1、创建一个测试目录

mkdir ~/docker-compose  ### 这里是在当前用户目录下创建的测试目录，这个目录你可以自定义。
cd ~/docker-compose

2、编写docker-compose.yml文件

vim docker-compose.yml ## 名字一定是docker-compose.yml 不然会报错

version: '3'
services:
  nginx:    ## 服务名，自己定义
   image: nginx:1.17 ## 镜像名
   ports: ## 宿主机和容器的端口映射，相当于docker run 后面的 -p 80:80
    - 80:80
   links:  ## 关联的服务
    - app
   volumes:  ## 挂载数据卷  相当于docker run 后面的 -v ./nginx/conf.d:/etc/nginx/conf.d
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: springbootdemo:1.1
    expose:
      - "8080"

3、创建nginx的配置目录

上面我们设置nginx的挂载目录，我们知道docker中的nginx默认使用的是etc/nginx/conf.d/目录下的default.conf配置。

我们在宿主机上的映射目录创建我们自己的nginx配置文件代替默认的配置文件。

4、创建./nginx/conf.d 目录

mkdir -p ./nginx/conf.d
vim mynginx.conf  ## 创建自己的nginx配置文件

server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}

上面是配置内容

5、启动docker-compose 文件

docker-compose up -d  ### 以后台形式启动编排的服务

6、测试访问

http:ip/helloDocker

image-20200502153704060

docker-compose常用命令

docker-compose up -d  # 在后台启动服务
docker-compose ps   # 查看启动的服务
docker-compose stop # 停止服务
docker-compose start # 启动服务
docker-compose restart # 重新启动服务

docker私有仓库（registy）

私有仓库搭建

# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json   
vim /etc/docker/daemon.json    
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["私有仓库服务器ip:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

将本地镜像上传到私有仓库

# 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7
 
# 2、上传标记的镜像     
docker push 私有仓库服务器IP:5000/centos:7

从私有仓库拉取镜像

#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

常用命令

镜像类

docker images [options]

docker images -a：列出本地所有的镜像

docker images -q：只显示镜像ID

docker images --digests：显示镜像的摘要信息

docker images —no-trunc：显示完整的镜像信息

docker search 某个镜像的名字：搜索相关镜像

docker pull 某个镜像的名字：拉取该镜像的latest版本

docker pull 某个镜像的名字:tag 拉取该镜像的指定版本（docker pull tomcat:9.0）

docker rmi -f 镜像ID f表示强制删除

docker rmi -f 镜像1ID:tag 镜像2ID:tag ：删除多个镜像

docker rmi -f $(docker images -aq) 删除全部

docker tag centos:7 私有仓库服务器IP:5000/centos:7：标记镜像为私有仓库的镜像

docker push 私有仓库服务器IP:5000/centos:7：上传标记的镜像

docker pull 私有仓库服务器ip:5000/centos:7：拉取镜像

容器类

docker run [options] ==IMAGER== [command] [ARG…]：新建并启动容器

OPTIONS说明（常用）：有些是一个减号，有些是两个减号

--name="容器新名字": 为容器指定一个名称；

-d: 后台运行容器，并返回容器ID，也即启动守护式容器；

-i：以交互模式运行容器，通常与 -t 同时使用；

-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；

-P: 随机端口映射；

-p: 指定端口映射，有以下四种格式

ip:hostPort:containerPort

ip::containerPort

hostPort:containerPort

containerPort

docker ps [options]：列出当前正在运行的容器

OPTIONS说明（常用）：

-a :列出当前所有正在运行的容器+历史上运行过的

-l :显示最近创建的容器。

-n：显示最近n个创建的容器。

-q :静默模式，只显示容器编号。

--no-trunc :不截断输出。

docker start 容器ID或容器名：启动容器

docker restart 容器ID或容器名：重启容器

docker stop 容器ID获或容器名：停止容器

docker kill 容器ID或容器名：强制停止容器

docker rm 容器ID或容器名: 删除容器

docker run -d 容器ID或容器名

很重要的要说明的一点: ==Docker容器后台运行,就必须有一个前台进程.==

Nginx我们正常是以后台进程启动的，但是在docker中的nginx我们会看到

nginx dockerfile 最后启动的命令是

==CMD ["nginx", "-g", "daemon off;"]==将nginx以前台进程的形式运行，这样保证docker有一个前台进程，docker不会退出。

docker从安装到实战看这篇就够了

相关官方地址

安装docker社区版(docker-ce) CentOS7环境

卸载docker

从官方仓库拉取docker镜像

用拉取的镜像创建一个mysql服务

创建一个Nginx服务

Docker容器数据卷

DockerFile

Docker镜像

Docker镜像构建的两种方式

Docker Compose

docker私有仓库（registy）

常用命令

你可能感兴趣的:(docker从安装到实战看这篇就够了)