Docker学习

Docker安装

准备工作

第一步：准备CentOS，以CentOS7为例进行安装。
第二步：基于vmware打开CentOS

第三步：克隆CentOS（选择链接克隆-更省空间），命名为CentOS7964-docker

开启虚拟机系统

第一步：启动虚拟机，默认账号密码为root/root

第二步：打开终端，通过ifconfig指令检查网络，

[root@centos7964 ~]# ifconfig
ens33: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 192.168.227.129  netmask 255.255.255.0  broadcast 192.168.227.255
        inet6 fe80::20c:29ff:fee9:918a  prefixlen 64  scopeid 0x20<link>
        ether 00:0c:29:e9:91:8a  txqueuelen 1000  (Ethernet)
        RX packets 287398  bytes 419668874 (400.2 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 127375  bytes 8442701 (8.0 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
        ....

第三步：通过MobaXterm工具链接虚拟机系统

卸载Docker

假如已经有docker，可通过执行如下指令卸载Docker

sudo yum remove docker-ce \
                docker-ce-client \
                docker-client-latest \
                docker-common \
                docker-latest \
                docker-latest-logrotate \
                docker-logrotate \
                docker-engine

在线安装Docker

第一步：安装一组工具

sudo yum install -y yum-utils 

第二步：设置 yum 仓库地址

【第一种】：使用国外官方源地址（比较慢）

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

【第二种】：选择国内的源地址（ 阿里云源地址）

sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

第三步：更新 yum 缓存

sudo yum makecache fast   #yum 是包管理器

第四步：安装新版 docker

sudo yum install -y docker-ce docker-ce-cli containerd.io

离线安装Docker

第一步：下载docker离线包

https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz

第二步：下载离线安装工具

https://github.com/Jrohy/docker-install/

说明，将下载好的这个工具解压。

第三步：将下载好的资源放在一个目录，例如：

在linux环境下，创建/root/setup/docker目录，然后拷贝下载好的资源到此目录（可通过MobaXterm或XShell工具直接上传到linux目录）

[root@centos7964 docker]# pwd
/root/setup/docker
[root@centos7964 docker]# ls -l
总用量 68132
-rw-r--r--. 1 root root 69637582 8月   4 13:04 docker-20.10.6.tgz
-rw-r--r--. 1 root root   114793 8月   4 13:04 docker.bash
-rwxr-xr-x. 1 root root     7546 8月   4 13:04 install.sh
[root@centos7964 docker]#

第四步：执行安装操作

# 进入/root/setup/docker 文件夹
cd /root/setup/docker
# 为 install.sh添加执行权限
chmod +x install.sh
# 安装
./install.sh -f docker-20.10.6.tgz

第五：安装成功以后，检查安装状态

docker info

Docker服务基本操作

启动docker服务

 systemctl start docker

查看docker状态

查看docker是否启动了,是否是运行状态.

systemctl status docker

设置docker开机自启

systemctl enable docker

禁用docker开机自启

systemctl disable docker

重新启动docker服务

 systemctl restart docker

查看docker信息

docker info

查看docker info中具体key的信息

例如:

docker info | grep 'Docker Root Dir:'

停止docker服务

systemctl stop docker

docker镜像加速

由于国内网络问题，需要配置加速器来加速。修改配置文件 /etc/docker/daemon.json

cd /etc/docker/ 

下面命令直接生成文件 daemon.json

cat <<EOF > /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF

说明：在执行如上指令时，保证你的登录用户为root管理员用户,并且设置好以后重启docker服务.

Docker镜像操作实践

镜像

Docker 镜像是一组静态磁盘文件，可以任意下载、复制、分发。从镜像可以运行启动容器（Docker的虚拟计算机）。

下载镜像

从镜像仓库 https://hub.docker.com 下载镜像：

语法：docker pull 镜像名

# 下载 redis 镜像， 默认下载 redis:latest
docker pull redis:5.0.12

查看下载的镜像文件

# 查看镜像列表
docker images

镜像的名称

镜像的名称由两部分组成：repository:tag，其中的 tag 一般用来表示版本，默认的 tag 是 latest，表示最近的版本。

镜像的名称相当于在镜像上贴的一个标签，在一个镜像上可以贴多个标签：

添加名称：

# 镜像可以起另一个名称，名称格式： repository:tag
# 默认的 tag 是 latest
docker tag redis:5.0.12 tedu/redis:v5012

# 查看镜像
# 可以看到同一个镜像（ID相同）可以有多个名称
docker images | grep redis

查看镜像详情

语法：docker inspect 镜像名或镜像id

docker inspect hello-world

查看镜像历史

一个镜像是由多个层（layer）组成的，那么，我们要如何知道各个层的具体内容呢？通过 docker history 命令，可以列出各个层（layer）的创建信息，可以查看默认的启动命令，例如：

docker history redis

docker history mariadb

docker history tomcat

ENTRYPOINT 和 CMD

这两项设置都是用来设置容器中运行的命令。

只设置 CMD 来执行 ls -a -l：

CMD ["ls", "-a", "-l"]

只设置 CMD 是常见的用法。

用 ENTRYPOINT 和 CMD 两个一起设置来执行 ls -a -l：

ENTRYPOINT ["ls"]
CMD ["-a", "-l"]

两项一起设置时，会把两项设置的内容连接起来作为一个完整的命令。

启动容器时覆盖 ENTRYPOINT 和 CMD

覆盖 CMD：
以 tomcat 镜像为例，镜像中设置的默认命令是 catalina.sh run，可以任意指定命令覆盖这个默认命令，这里执行 ls -a -l来测试：

docker run tomcat ls -a -l

覆盖 ENTRYPOINT：
--entrypoint：设置运行的命令，不许写在镜像名称 tomcat 的前面。注意，这里不能添加命令的参数；

镜像名称tomcat 后面的内容会覆盖 CMD

docker run --entrypoint ls tomcat -a -l

导出镜像文件(存起来)

镜像导出(linux系统中的镜像文件下载到本地-例如window)，导出后给他人使用
可以另创建一个文件夹，cd到此文件夹，在进行导出到此文件夹

docker save  hello-world | gzip > hello-world.tar.gz  

删除镜像文件

镜像的名称可以被删除，只有唯一的一个名称时会删除镜像：
语法：docker image rm 镜像名或镜像id

docker image rm hello-world

或者

docker rmi redis:5.0.12

导入镜像操作(加载进来)

镜像导入（要在hello-world.tar.gz 文件所在目录下执行）

docker load < hello-world.tar.gz  

docker load -i imgs.gz

导出镜像操作

导出镜像并压缩到压缩文件：

# 把两个镜像 redis:latest 和 centos:8 导出，并压缩到 imgs.gz
docker save redis centos:8 | gzip > imgs.gz

Docker容器操作

下载镜像

通过docker pull指令下载CentOS镜像，例如：

docker pull centos:7

说明，官方镜像仓库地址为https://hub.docker.com/

下载完以后，查看centos7镜像文件。

docker images

创建并启动容器

基本语法解析：

docker run -it xxxx bash

其中：
1) xxxx 表示镜像名或 image id 的前几位；
2) -it 这是两个参数( -i 表示交互式操作， -t 表示终端 )；
3) bash 表示进入操作终端，基于交互式进行相关操作（ 例如执行linux相关指令 ）。

案例：通过docker启动运行 centos7镜像

docker run -it centos:7 bash

查看Docker中的容器

查看docker运行中的容器

docker ps

查看docker运行中的所有容器

docker ps -a

其中，-a表示全部(all）。

查看容器日志信息

查看后台运行的容器输出结果，这个指令非常重要，假如容器没有启动，要通过此指令去看一下错误日志。

docker logs 802 

或

docker container logs 802  #自己的容器id（一般写前三位即可）

停止或重启容器

停止运行的容器，代码如下：

docker container stop 802

重新启动容器，代码如下：

docker container restart 802

进入指定容器

当需要进入容器进行操作时（容器运行着），可以使用 docker exec 命令，例如：

docker exec -it 802 bash  #802为容器id

退出容器

假如从宿主机进入了启动的容器，退出容器需要使用exit指令，例如：

exit

删除容器

假如容器不用了，可执行删除操作，例如：

docker container rm 802  #802为容器id

其中，如果删除运行中的容器，需要添加 -f 参数。

清理所有终止状态容器，例如：

docker container rm 802  #802为容器id

–name 和 --restart=always

--name：
每个启动的容器都可以指定一个名称，方便使用名称来操作容器。

--restart=always：
docker系统服务重启，或者操作系统重启，容器可以随系统自动启动。

# cat1容器可以随系统启动
docker run -d \
--name cat1 \
--restart=always \
tomcat

# cat2系统重启后默认是关闭状态，不会自动启动
docker run -d \
--name cat2 \
tomcat

# 查看容器
docker logs cat1

docker inspect cat1

# 重启docker系统服务
systemctl restart docker

# 查看容器，可以看到 cat1 自动重启了，而 cat2 处于关闭状态
docker ps -a

–rm 和 docker cp

--rm：
有时候我们会临时使用一个容器之后这个容器就不再使用，添加 --rm 参数可以在容器停止时自动删除容器

docker cp：
在容器和宿主机之间复制文件

下面来看一个实际的例子，这个例子中我们从 tomcat 的一个临时容器复制配置文件 server.xml 到宿主机，然后在 server.xml 中修改端口号，把 8080 改成 80。

# 启动一个临时容器
docker run -d \
--rm \
--name tmp \
tomcat

# 把 tomcat 的 server.xml 复制到宿主机的 /root/ 目录下
docker cp tmp:/usr/local/tomcat/conf/server.xml  /root/

# 停止临时容器，会自动删除
docker stop tmp

docker ps -a

# 修改 server.xml 中的8080端口，改成80
vim server.xml

# -v 把宿主机路径挂载到容器的一个路径
# 挂载的路径可以是文件，也可以是文件夹
# 这里把修改过的 server.xml 挂载到新启动的容器中
docker run -d \
--name cat2 \
-v /root/server.xml:/usr/local/tomcat/conf/server.xml \
tomcat

# 查看启动日志，确认使用 80 端口启动
docker logs cat2

Docker数据管理

概述

在容器中管理数据主要有两种方式：

• 挂载主机目录 (Bind mounts)-最常用 (docker run -v 宿主机目录:容器目录)
• 数据卷（Volumes）

数据卷

数据卷是一个可供一个或多个容器使用的特殊目录，可以在容器之间共享和重用，默认会一直存在，即使容器被删除。

数据卷操作

第一步：创建数据卷，例如：

docker volume create container-vol

第二步：查看所有数据卷，例如：

docker volume ls

查看指定 数据卷 的信息

docker volume inspect container-vol

查询的结果：

[
    {
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/container-vol/_data",
        "Name": "container-vol",
        "Options": {},
        "Scope": "local"
    }
]

第三步：启动挂载数据卷的容器，例如：

docker run -it --mount source=container-vol,target=/root centos:7 bash

或者采用如下简写方式

docker run -it -v container-vol:/root centos:7 bash

-v container-vol:/root 把数据卷 container-vol 挂载到容器的 /root 目录

第四步：删除数据卷(如果数据卷被容器使用则无法删除)，例如

docker volume rm container-vol

清理无主数据卷

docker volume prune

挂载主机目录

我们还可以在启动容器时，以目录直接挂载的方式进行数据操作，例如：

docker run -it -v /usr/app:/opt/app centos:7 bash

其中：
1)/usr/app：为宿主机目录(若不存在，则自动创建)
2)/opt/app: 为启动容器的一个目录
3)-v 用于指定挂载目录，如果本地目录(宿主机目录)不存在， Docker 会自动为你按照挂载目录进行目录的创建。

例如:

查看挂载目录信息

docker restart 91a   #91a 为容器id

docker inspect 91a

显示结果：

...

"Mounts": [
    {
        "Type": "bind",
        "Source": "/usr/app",
        "Destination": "/opt/app",
        "Mode": "",
        "RW": true,
        "Propagation": "rprivate"
    }
],

...

-v 目录挂载

上面例子中用到-v 参数，他可以将宿主机的路径挂载到容器指定路径，通过 -v 参数可以挂载文件、目录和数据卷。

挂载目录：

# 清理容器
docker rm -f $(docker ps -aq)

# -v 宿主机路径:容器路径
# 挂载的可以是文件，也可以是文件夹
# -v 可以在宿主机自动新建目录
docker run -d \
--name cat1 \
-v /usr/app:/opt/app \
tomcat

# 进入容器，在 /opt/app 下新建文件 f1.txt
docker exec -it cat1 bash

touch /opt/app/f1.txt

# 退出容器的命令行
exit

# 访问宿主机的文件夹
cd /usr/app
ls

数据卷挂载

# 新建数据卷
docker volume create my-vol

# 查看 my-vol 数据卷的信息
docker volume ls

# /var/lib/docker/volumes/my-vol/_data
docker inspect my-vol

# 挂载 my-vol 数据卷到容器的 /opt/app 路径
docker run -d \
--name cat2 \
-v my-vol:/opt/app \
tomcat

# 在容器的 /opt/app 下新建 f2.txt
docker exec -it cat2 bash

touch /opt/app/f2.txt

# 退出容器的命令行
exit

# 进入 my-vol 数据卷的真实目录，查看 f2.txt
cd /var/lib/docker/volumes/my-vol/_data

ls

Dockerfile及镜像制作

背景

我们从基于docker pull指令可以从远程仓库下载我们需要的一些镜像(image),但是镜像仓库中的镜像是从哪里来的呢,假如镜像仓库中没有我们需要的镜像呢,所以本小结我们会讲解我们自己如何制作镜像.

镜像制作分析

Dockerfile 是一个用来构建镜像的文本文件,文本内容包含了一条条构建镜像所需的指令和说明。我们通常会基于此文件创建docker镜像,例如:

制作 JDK 镜像

准备工作

1. centos:7镜像 (所有的镜像文件创建时都需要有一个空的centos镜像，就类似通过一个空的光盘或u盘创建一个系统启动盘是一样的)
2. jdk压缩包 jdk-8u51-linux-x64.tar.gz(可以从官网去下载:oracle.org)，基于此压缩包，制作jdk镜像。

例如:JDK 拷贝的目录

创建Dockerfile文件

在创建新的镜像时都需要有一个Dockerfile文件(文件名一定要注意大小写)，这个文件要与你的资源放在一起(例如你下载的jdk)，我们可以通过linux系统中的touch指令创建此文件（touch Dockerfile）

现在，以centos7为基础，构建oracle jdk8的镜像，首先通过vim打开Dockerfile，这个文件不存在会自动创建。然后进入编辑模式(按i字母)，在编辑模式下可以拷贝如下语句（自己手动写也可以，但确保写的单词正确，大小写，空格）。
第一步：编写FROM语句(关键字一定要大写，例如FROM不能写小写)

FROM centos:7

第二步：通过ADD命令将宿主机中的压缩包传入镜像容器中的指定目录,并同时解压缩

ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker

第三步：设置环境变量(通过ENV关键字实现，目录启动容器中的目录)

ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 \
    PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH

完整示例如下：（注意关键字与后面内容之间的空格，可以将如下完成示例拷贝Dockerfile文件，但是一定要注意你的jdk名字是什么）

FROM centos:7
ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker
ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 \
    PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH
CMD ['bash']

第五步:然后按shift+冒号,输入wq保存退出.目录结构如下:

创建JDK镜像文件

使用 Dockerfile 构建镜像(必须在Dockerfile所在目录执行以下docker指令)

docker build -t jdk:8 .  #不要丢掉这里的点, -t表示镜像标识(镜像名), 是tag单词的缩写.

注意末尾的点,表示构建过程中从当前目录寻找文件，jdk:8为我们创建的镜像名。

运行JDK镜像(image)文件

在宿主机中执行如下指令,启动JDK容器,例如:

docker run -it jdk:8 bash

进入容器以后，可以通过echo $PATH查看环境变量，并可以通过java –version查看JDK版本信息。

基于JDK镜像启动sentinel

FAQ：如何通过此镜像运行一个web服务，例如sentinel等。

第一步：将sentinel拷贝宿主机指定目录，例如/root/servers目录(servers目录不存在可以自己创建)。

第二步：启动镜像容器，通过java执行运行web服务

基于jdk:8镜像启动运行sentinel服务(服务启动后可在宿主机通过localhost:8180进行访问)

docker run -d  -p 8180:8080 --name sentinel  \
-v /root/servers:/usr/sca  \
jdk:8 java -jar /usr/sca/sentinel-dashboard-1.8.0.jar

例如

其中:

1. -d 表示后台运行
2. -p 用于实现端口映射(假设外部要访问这个容器,必须要做端口映射)
3. –name 表示为启动的容器起一个名字

这里,服务启动后可通过docker ps 指令查看启动的服务,假如看不到服务,可能服务启动失败,可通过如下指令查看具体日志

docker container logs  689 #这里689为容器id,也可以为你的容器名

我们访问sentinel服务时需要通过宿主机进行访问,不可以直接访问,所以要做端口映射,例如

第三步:打开浏览器,访问sentinel服务.
在windows中打开浏览器,输入你的ip地址(这个ip为远端宿主机的ip地址),端口号为宿主机的端口号.例如

构建 tomcat 镜像

构建镜像类似于一台电脑的装机过程，添加文件、安装软件、配置环境…

例如构建一个 tomcat 10 镜像流程，就像在一台电脑上安装配置 tomcat 环境一样：

1. 选择基础镜像 centos:8（相当于一台新电脑，只有操作系统）
2. 添加 jdk 和 tomcat 10 文件
3. 设置环境变量
4. 设置默认文件夹
5. 暴露端口（只影响 -P 参数）
6. 设置启动命令
7. 设置开机启动 tomcat 10

下面来演示构建 tomcat 10 镜像的过程：

准备必要的文件

jdk 和 tomcat 10 的压缩文件放入一个文件夹中，这个文件夹不应该包含其他无关文件：

[/root/tomcat/]
       - jdk-8u291-linux-x64.tar.gz
       - apache-tomcat-10.0.6.tar.gz

Dockerfile

Dockerfile 类似于一个批处理文件，用来设置镜像的构建流程

在上一步的 tomcat 文件夹下创建 Dockerfile 文件：

[/root/tomcat/]
       - jdk-8u291-linux-x64.tar.gz
       - apache-tomcat-10.0.6.tar.gz
       - Dockerfile

编辑 Dockerfile 文件

cd /root/tomcat

vim Dockerfile

在文件中添加以下内容：

# 1.选择基础镜像
FROM centos:8

# 2.添加 jdk 和 tomcat 10 文件
# jdk 和 tomcat 文件添加到镜像的 /usr/local/ 目录下
# ADD 指令会自动解压文件
ADD jdk-8u291-linux-x64.tar.gz apache-tomcat-10.0.6.tar.gz /usr/local/

# 3.设置环境变量
ENV JAVA_HOME=/usr/local/jdk1.8.0_291 \
    CATALINA_HOME=/usr/local/apache-tomcat-10.0.6 \
    PATH=/usr/local/jdk1.8.0_291/bin:/usr/local/apache-tomcat-10.0.6/bin:$PATH

# 4.切换到镜像中指定的文件夹下
WORKDIR /usr/local/apache-tomcat-10.0.6/

# 5.暴露端口（只影响 -P 参数）
# EXPOSE 8080 只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务
# 这个声明有两个好处：
#   1.帮助镜像使用者理解这个镜像服务的端口，以方便配置映射
#   2.在运行时使用随机端口映射时，也就是 docker run -P时，会自动随机映射 EXPOSE 的端口
EXPOSE 8080

# 6.设置启动命令
CMD ["catalina.sh", "run"]

创建 tomcat 镜像文件

docker build -t tomcat:10 /root/tomcat  #若不在当前文件夹下，可使用绝对路径
或者
docker build -t tomcat:10 ./  #若在当前文件夹下，可使用相对路径

查看 tomcat 镜像文件

镜像创建之后就不能再修改了

用 tomcat:10 部署一个 helloworld web应用

1.准备 jsp 文件

mkdir /opt/web
vim /opt/web/index.jsp

2.添加如下内容

<h1>Hello World<h1>
<h1>Hello ${param.name}<h1>

3.启动 tomcat:10 容器

docker run -d --name web \
--restart=always \
-p 80:8080 \
-v /opt/web:/usr/local/apache-tomcat-10.0.6/webapps/ROOT \
tomcat:10

3.访问 http://192.168.64.150 、 http://192.168.64.150/?name=zhangsan

制作 Sentinel 镜像(练习）

准备工作

1. centos:7镜像(课前资料中的)
2. jdk-8u51-linux-x64.tar.gz(可以从课前资料获取)
3. sentinel-dashboard-1.8.0.jar

说明,通过docker images指令查看centos:7是否存在,然后将 jdk-8u51-linux-x64.tar.gz,sentinel-dashboard-1.8.0.jar放在/root/setup/sentinel目录(目录不存在的话自己创建)

构建 Sentinel 镜像

第一步：在sentinel所在目录创建Dockerfile文件,并添加如下内容

FROM centos:7
ADD jdk-8u51-linux-x64.tar.gz  /usr/local/
ADD sentinel-dashboard-1.8.0.jar  /usr/local/
ENV JAVA_HOME=/usr/local/jdk1.8.0_51 \
    PATH=/usr/local/jdk1.8.0_51/bin:$PATH
EXPOSE 8080
ENTRYPOINT ["java","-jar","/usr/local/sentinel-dashboard-1.8.0.jar"]

其中,EXPOSE表示对外暴露的服务端口,ENTRYPOINT中写的是你容器启动时候要执行的指令.

第二步:使用 Dockerfile 构建镜像(在Dockerfile所在目录执行docker指令)

docker build -t  sentinel:8 .  #不要丢掉这里的点

第三步：运行sentinel容器

docker run -d -p 8180:8080 sentinel:8

若端口冲突，则暴以下错误：

处理方法：要么关了该重复的端口，要么换一下端口；例如(8180换为8181)：

docker run -d --name sentinel8181 -p 8181:8080 sentinel:8  #-d 表示后台运行,-p用于指定端口映射,sentinel:8为镜像文件名

第四步:查看sentinel容器

docker ps

假如看不到容器,可通过"docker container logs 容器id"方式查看容器状态.

第五步:访问sentinel服务

可以在window中访问时你的linux系统中启动的sentinel服务,ip地址应该为宿主机的ip地址,端口号为宿主机的端口号.例如

安装MySql数据库

安装步骤

第一步：在hub.docker.com上搜索mysql镜像

第二步：拉取指定版本的mysql，也可以指定拉取版本，例如：

 docker pull mysql:8.0.23

第三步：检查mysql镜像

 docker images

第四步：启动运行mysql镜像 (docker run 用于启动一个容器)

sudo docker run -p 3306:3306 --name mysql \
-v /usr/local/docker/mysql/mysql-files:/var/lib/mysql-files \
-v /usr/local/docker/mysql/conf:/etc/mysql \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:8.0.23

假如安装过程中失败了，则可通过docker ps -a 查看以前的容器，假如已存在，则通过docker rm 镜像id 删除再重新安装即可。

登陆mysql服务

第一步：进入容器 (退出容器用exit)

docker exec -it mysql bash

第二步：登陆(默认密码root)，一定要先进入mysql容器。

mysql -uroot -proot

停止和启动mysql服务

停止mysql服务（可选）

docker stop mysql

启动mysql服务

docker start mysql

假如希望查看mysql启动时的日志，可以执行 docker container logs mysql 这个指令。

设置mysql开机自启动（可选）

docker update mysql --restart=always

安装Redis数据库

安装步骤

第一步：下载镜像文件

docker pull redis

第二步：准备配置文件

创建redis配置文件目录

mkdir -p /usr/local/docker/redis01/conf

在配置文件录下创建redis.conf配置文件(这个文件一定要创建，否在我们进行目录挂载时默认生成的是一个目录)

touch /usr/local/docker/redis01/conf/redis.conf

第三步：创建redis实例并启动

sudo docker run -p 6379:6379 --name redis01 \
-v /usr/local/docker/redis01/data:/data \
-v /usr/local/docker/redis01/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf 

第四步：查看正在运行的进程

docker ps

访问redis服务器

第一步：控制台直接连接redis测试

docker exec -it redis01 bash

第二步：检测redis 版本

redis-server  -v

或者

redis-cli -v

第三步：登录redis(默认不需要密码)

redis-cli

或者直接将上面的两个步骤合为一个步骤执行也可以，指令如下：

docker exec -it redis01 redis-cli

停止和启动redis服务

停止redis服务？

docker stop redis01

启动redis服务？

docker start redis01

重启 redis 服务？

docker restart redis01

安装Ngnix代理

安装步骤

第一步：拉取ngnix镜像 （从这里hub.docker.com去查找）

docker pull nginx

第二步：查看images镜像

docker images

第三步:创建数据卷(这个对象会在宿主机直接创建一个目录)

docker volume create nginx-vol

说明:查看数据卷对应的宿主机目录,可以通过如下指令:

docker inspect nginx-vol

第四步：启动nginx服务

docker run --name nginx  -p 80:80 -v nginx-vol:/etc/nginx -d nginx

其中:/etc/nginx 为nginx容器启动时,nginx镜像文件默认的解压目录

说明:假如以后想修改nginx配置,可以直接去nginx-vol数据卷对应的目录去修改.

访问nginx服务

进行访问检测，如图所示：

停止和nginx服务

停止nginx服务

docker stop nginx

启动nginx服务

docker start nginx

重启nginx服务

docker restart nginx

安装Nacos

安装步骤

第一步：拉取nacos（hub.docker.com）

docker pull nacos/nacos-server:1.4.1

第二步： mysql中执行nacos的sql脚本文件

1)将此文件nacos-mysql.sql(这个文件可从code服务器下载)拷贝到mysql容器的宿主机对应的挂载目录(可通过docker inspect mysql查看你mysql的挂载目录)

2)在linux环境下启动并登录mysql

进入mysql容器(前提是mysql已启动)

docker exec -it mysql bash

登录mysql

mysql -uroot -p

3)通过source指令运行容器目录下的sql文件

source  /etc/mysql/nacos-mysql.sql    #这里的/etc/mysql为容器中的一个目录(要选择你自己挂载的目录)

第三步：创建并启动nacos容器

docker run  \
-e TZ="Asia/Shanghai" \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_DATABASE_NUM=1 \
-e MYSQL_SERVICE_HOST=192.168.126.129 \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=root \
-e MYSQL_SERVICE_PASSWORD=root \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
-p 8848:8848 \
--name nacos \
--restart=always \
-d nacos/nacos-server:1.4.1

参数说明

• 单节点模式 MODE=standalone
• 数据库地址 MYSQL_SERVICE_HOST
• 数据库用户名 MYSQL_SERVICE_USER
• 数据库密码 MYSQL_SERVICE_PASSWORD
• 需连接的数据库名称 MYSQL_SERVICE_DB_NAME
• 端口映射 -p 8848:8848
• 任意时候重启容器，开机就能自动启动容器（需设置docker为开机自启）–restart=always

第四步：检查nacos服务

docker ps

假如启动失败，检查启动日志，例如：

docker container logs nacos

其中，nacos的启动日志在/home/nacos/logs/start.out文件中。

访问nacos服务

启动nacos，然后在windows中输入http://ip:port/nacos方式进行访问测试

Nacos 与 MySQL 通讯分析

停止和启动nacos服务

停止nacos服务

docker stop nacos

启动nacos服务

docker start nacos

重启nacos服务

docker restart nacos

Docker 容器互联

简介

Docker 中存在多个容器时，容器与容器之间经常需要进行通讯，例如nacos访问mysql，redis集群中各个节点之间的通讯。

解决方案

Docker 中容器与容器之间进行通讯的解决方案一般有两种：
第一种：两个容器通过宿主机进行通讯（容器中的端口会映射到宿主机上）
第二种：两个容器之间直接通过虚拟网络进行连接,但是需要我们在docker中创建网络。

初始化网路

架构设计

新建网络

例如：创建名字为t-net的网络

docker network create -d bridge t-net  #t-net为自己起的网络名称

其中，-d driver,网络类型，默认 bridge。
说明，创建好这个网络以后，在网落上添加容器，容器就可以通讯了

查看网络信息

列出所属有网络

docker network ls

查看网络信息

docker inspect 67d   #67d 为创建的网络id

实现容器互联

创建容器

打开终端，基于centos:7这个镜像启动容器，并加入到t-net这个网络

docker run -it --name app1 --network t-net centos:7

新开终端执行，基于centos:7这个镜像再启动容器，同时也加入到t-net网络

docker run -it --name app2 --network t-net centos:7

测试网络互通

在两个终端中分别执行：

ping app1

ping app2

显示如下：

[root@35569c623c4c /]# ping app1
PING app1 (172.18.0.2) 56(84) bytes of data.
64 bytes from 35569c623c4c (172.18.0.2): icmp_seq=1 ttl=64 time=0.577 ms
64 bytes from 35569c623c4c (172.18.0.2): icmp_seq=2 ttl=64 time=0.061 ms
64 bytes from 35569c623c4c (172.18.0.2): icmp_seq=3 ttl=64 time=0.066 ms
......

查看app1的ip地址：在宿主机中输入下面代码

docker insepct app1

端口映射

客户端要访问宿主机内部运行的容器时，可以在宿主机打开一个端口，当客户单访问这个端口时，可以将访问转发到内部的容器。

-p 参数：
通过 -p 参数设置，可以在宿主机上选择一个端口映射到容器的端口。

# 清理容器
docker rm -f $(docker ps -aq)

# 端口映射
# -p 宿主机端口:容器端口
docker run -d \
--name cat1 \
-p 80:8080 \
tomcat

浏览器访问宿主机映射的端口 80
http://192.168.64.150

看到 tomcat 返回的 404 页，说明已经正常访问到 tomcat 容器

-P参数
通过-P参数设置，可以在宿主机上选择P一个端口映射到容器的端口。

docker run -d \
--name cat2 \
-P \
tomcat

访问 http://192.168.64.150:49153

虚拟网络

容器键互联可以使用 Docker 的虚拟网络来连接。

在 Docker 中可以创建任意多个虚拟网络，容器之间可以通过虚拟网络互联互通。创建虚拟网络时宿主机也会连接到虚拟网络。

# 新建虚拟网络 my-net
docker network create my-net

# 查看虚拟网络
docker network ls

# 查看网络描述信息
docker inspect my-net

# 查看宿主机新建的虚拟网卡
ifconfig

# 清理容器
docker rm -f $(docker ps -aq)

# 新建两个容器 cat1 和 cat2
# 连接到虚拟网络 my-net
docker run -d --name cat1 \
--net my-net \
tomcat

docker run -d --name cat2 \
--net my-net \
tomcat

# 查看两个容器的虚拟网络ip
docker inspect cat1
docker inspect cat2

# 测试网络能否互联互通
# 从宿主机ping两个容器
ping 172.18.0.2
ping 172.18.0.3

# 进入cat1，ping宿主机和cat2
docker exec -it cat1 ping 172.18.0.1
docker exec -it cat1 ping 172.18.0.3
# 从容器访问另一个容器，可以使用容器名称访问，容器内部实现了解析环境
docker exec -it cat1 ping cat2