docker简介以及docker安装redis、mysql并实现数据挂载宿主机

Myth丶恋晨 2024-03-17 19:24 77阅读 0赞

#### 文章目录 ####

*   *   *  1、简介
         *  2、前提
         *   *  2.1 前提条件：
             *  2.2查看自己的内核
         *  3、基本组成
         *   *  3.1 镜像：
             *  3.2 容器：
             *  3.3 仓库：
         *  4、安装
         *   *  4.1 确定版本：
             *  4.2 卸载旧版本
             *  4.3 yum安装gcc相关
             *  4.4 安装所需软件包
             *  4.5 设置stable镜像仓库（阿里云镜像仓库）
             *  4.6 更新yum软件包索引
             *  4.7 安装 Docker CE
             *  4.8 启动docker
             *  4.9 测试
             *  4.10 阿里云镜像加速配置
             *  4.11 卸载docker
         *  5、常用命令：
         *   *  5.1 帮助启动类
             *  5.2 镜像类
             *  5.3 容器类
             *  5.4 重要补充
             *  5.5 小总结
         *  6、Docker镜像
         *   *  6.1 镜像的分层
             *  6.2 commit命令
             *  6.3 总结
         *  7、本地镜像发布
         *   *  7.1 公有仓库
             *  7.2 私有仓库
         *  8、容器数据卷
         *   *  8.1 注意！！！
             *  8.2 数据卷
             *  8.3 数据卷案例
             *  8.4 读写规则映射添加说明
         *  9、Docker上常规软件安装
         *   *  9.1 安装tomcat
             *  9.2 安装mysql
             *   *  简单版
                 *  实战版
             *  9.3 安装redis

--------------------

#### 1、简介 ####

1.  官网
    
    docker官网：http://www.docker.com
    
    仓库
    
    Docker Hub官网: https://hub.docker.com/

#### 2、前提 ####

##### 2.1 前提条件： #####

**Docker必须部署在Linux内核的系统上**

目前，CentOS 仅发行版本中的内核支持 Docker。Docker 运行在CentOS 7 (64-bit)上，

要求系统为64位、Linux系统内核版本为 3.8以上

##### 2.2查看自己的内核 #####

uname命令用于打印当前系统相关信息（内核版本号、硬件架构、主机名称和操作系统类型等）。

[root@localhost /]# cat /etc/redhat-release 
    CentOS Linux release 7.3.1611 (Core) 
    [root@localhost /]# 
    [root@localhost /]# uname -r
    3.10.0-514.el7.x86_64
    [root@localhost /]#

#### 3、基本组成 ####

##### 3.1 镜像： #####

Docker 镜像（Image）就是一个**只读**的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。

它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。

相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于java中new出来的实例对象。

![在这里插入图片描述][043daeced26a4866b6018baed31d1965.png]

##### 3.2 容器： #####

1.  从面向对象角度：
    
    Docker 利用容器（Container）独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台
2.  从镜像容器角度：
    
    \***可以把容器看做是一个简易版的 Linux 环境\***（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

##### 3.3 仓库： #####

**集中存放镜像**文件的场所

类似于

Maven仓库，存放各种jar包的地方；

github仓库，存放各种git项目的地方；

Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub(https://hub.docker.com/)

#### 4、安装 ####

docker官网安装：https://docs.docker.com/engine/install/centos/

##### 4.1 确定版本： #####

# 确定Centos7及以上版本
    [root@localhost /]# cat /etc/redhat-release 
    CentOS Linux release 7.3.1611 (Core) 
    [root@localhost /]#

##### 4.2 卸载旧版本 #####

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

##### 4.3 yum安装gcc相关 #####

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

##### 4.4 安装所需软件包 #####

yum install -y yum-utils

##### 4.5 设置stable镜像仓库（阿里云镜像仓库） #####

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

##### 4.6 更新yum软件包索引 #####

yum makecache fast

##### 4.7 安装 Docker CE #####

yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

##### 4.8 启动docker #####

systemctl start docker

##### 4.9 测试 #####

docker version
    docker run hello-world

##### 4.10 阿里云镜像加速配置 #####

sudo mkdir -p /etc/docker
    sudo tee /etc/docker/daemon.json <<-'EOF'
    {
      "registry-mirrors": ["https://zkplqh8u.mirror.aliyuncs.com"]
    }
    EOF
    sudo systemctl daemon-reload
    sudo systemctl restart docker

##### 4.11 卸载docker #####

systemctl stop docker
    sudo yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
    sudo rm -rf /var/lib/docker
    sudo rm -rf /var/lib/containerd

#### 5、常用命令： ####

##### 5.1 帮助启动类 #####

1.  启动docker：
    
        systemctl start docker
2.  停止docker：
    
        systemctl stop docker
3.  重启docker：
    
        systemctl restart docker
4.  查看docker状态：
    
        systemctl status docker
5.  开机启动：
    
        systemctl enable docker
6.  查看docker概要信息：
    
        docker info
7.  查看docker总体帮助文档：
    
        docker --help
8.  查看docker命令帮助文档：
    
        docker 具体命令 --help

##### 5.2 镜像类 #####

1.  列出本地主机上的镜像：
    
        docker images [OPTIONS]
        
        # OPTIONS说明：
        -a :列出本地所有的镜像（含历史映像层）
        -q :只显示镜像ID。
2.  搜索远程仓库中有没有xxx的镜像：
    
        docker search xxx [OPTIONS]
        
        # OPTIONS说明：
        --limit :只列出N个镜像，默认为5
3.  下载镜像：
    
        # 没有Tag就是最新版
        docker pull xxx
4.  查看镜像/容器/数据卷 所占的空间
    
        docker system df
5.  删除镜像
    
        # 删除单个
        docker rmi -f 镜像ID
        # 删除多个
        docker rmi -f 镜像名1:Tag 镜像名2:Tag
        docker rmi -f 镜像1ID 镜像2ID
        # 删除全部
        docker rmi -f $(docker images -qa)
        # 清理无用镜像
        docker image prune -a

注：谈谈docker虚悬镜像是什么？

仓库名、标签都是 的镜像

##### 5.3 容器类 #####

**有镜像才能创建容器**

1.  新建+启动容器 : docker run -it centos /bin/bash
    
        docker run [OPTIONS] IMAGE [COMMAND]
        
        # OPTIONS说明（常用）：有些是一个减号，有些是两个减号
        --name="容器新名字"       为容器指定一个名称；
        
        -d: 后台运行容器并返回容器ID，也即启动守护式容器(后台运行)；
        -i：以交互模式运行容器，通常与 -t 同时使用；
        -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；
        也即启动交互式容器(前台有伪终端，等待交互)；
        -P: 随机端口映射，大写P
        -p: 指定端口映射，小写p
        
        eg: docker run -it centos /bin/bash 
        使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令
        参数说明：
        -i: 交互式操作。
        -t: 终端。
        centos : centos 镜像。
        /bin/bash：放在镜像名后的是命令，这里我们希望有个交互式 Shell，因此用的是 /bin/bash。
        要退出终端，直接输入 exit:
2.  列出当前正在运行的所有容器
    
        docker ps [OPTIONS]
        
        # OPTIONS说明（常用）：
        -a :列出当前所有正在运行的容器+历史上运行过的
        -l :显示最近创建的容器。
        -n：显示最近n个创建的容器。
        -q :静默模式，只显示容器编号。
3.  退出容器
    
        exit
        # run进去容器，exit退出容器，容器停止
        
        ctrl+p+q
        # run进去容器，ctrl+p+q退出容器，容器不停止
4.  启动已停止运行的容器
    
        docker start 容器id或容器名
5.  重启容器
    
        docker restart 容器id或容器名
6.  停止容器
    
        docker stop 容器id或容器名
7.  强制停止容器（不能滥用）
    
        docker kill 容器id或容器名
8.  删除已停止的容器
    
        docker rm 容器id

##### 5.4 重要补充 #####

**有镜像才能创建容器，这是重要前提**

1.  启动守护式容器（后台服务器）
    
    大部分情况下，我们希望docker的服务是在后台运行的，我们可以通过 -d 指定容器的后台运行方式
    
        docker run -d 容器名
        
        # 问题：然后docker ps -a 进行查看, 会发现容器已经退出
        很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程.
        容器运行的命令如果不是那些一直挂起的命令（比如运行top，tail），就是会自动退出的。
         
        
        这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下,
        
        我们配置启动服务只需要启动响应的service即可。例如service nginx start
        
        但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,
        
        这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.
        
        所以，最佳的解决方案是,将你要运行的程序以前台进程的形式运行，
        
        常见就是命令行模式，表示我还有交互操作，别中断，O(∩_∩)O哈哈~
        
        
        # 前台交互：
        docker run -it redis
        # 后台守护：
        docker run -d redis
2.  查看容器日志
    
        docker logs 容器ID
3.  查看容器内运行的进程
    
        docker top 容器ID
4.  查看容器内部细节
    
        docker inspect 容器ID
5.  **进入正在运行的容器并以命令行交互**
    
        docker exec -it 容器ID bash
6.  从容器内拷贝文件到主机上
    
        docker cp  容器ID:容器内路径 目的主机路径

##### 5.5 小总结 #####

attach    Attach to a running container                 # 当前 shell 下 attach 连接指定运行镜像
    
    build     Build an image from a Dockerfile              # 通过 Dockerfile 定制镜像
    
    commit    Create a new image from a container changes   # 提交当前容器为新的镜像
    
    cp        Copy files/folders from the containers filesystem to the host path   #从容器中拷贝指定文件或者目录到宿主机中
    
    create    Create a new container                        # 创建一个新的容器，同 run，但不启动容器
    
    diff      Inspect changes on a container's filesystem   # 查看 docker 容器变化
    
    events    Get real time events from the server          # 从 docker 服务获取容器实时事件
    
    exec      Run a command in an existing container        # 在已存在的容器上运行命令
    
    export    Stream the contents of a container as a tar archive   # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
    
    history   Show the history of an image                  # 展示一个镜像形成历史
    
    images    List images                                   # 列出系统当前镜像
    
    import    Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
    
    info      Display system-wide information               # 显示系统相关信息
    
    inspect   Return low-level information on a container   # 查看容器详细信息
    
    kill      Kill a running container                      # kill 指定 docker 容器
    
    load      Load an image from a tar archive              # 从一个 tar 包中加载一个镜像[对应 save]
    
    login     Register or Login to the docker registry server    # 注册或者登陆一个 docker 源服务器
    
    logout    Log out from a Docker registry server          # 从当前 Docker registry 退出
    
    logs      Fetch the logs of a container                 # 输出当前容器日志信息
    
    port      Lookup the public-facing port which is NAT-ed to PRIVATE_PORT    # 查看映射端口对应的容器内部源端口
    
    pause     Pause all processes within a container        # 暂停容器
    
    ps        List containers                               # 列出容器列表
    
    pull      Pull an image or a repository from the docker registry server   # 从docker镜像源服务器拉取指定镜像或者库镜像
    
    push      Push an image or a repository to the docker registry server    # 推送指定镜像或者库镜像至docker源服务器
    
    restart   Restart a running container                   # 重启运行的容器
    
    rm        Remove one or more containers                 # 移除一个或者多个容器
    
    rmi       Remove one or more images       # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]
    
    run       Run a command in a new container              # 创建一个新的容器并运行一个命令
    
    save      Save an image to a tar archive                # 保存一个镜像为一个 tar 包[对应 load]
    
    search    Search for an image on the Docker Hub         # 在 docker hub 中搜索镜像
    
    start     Start a stopped containers                    # 启动容器
    
    stop      Stop a running containers                     # 停止容器
    
    tag       Tag an image into a repository                # 给源中镜像打标签
    
    top       Lookup the running processes of a container   # 查看容器中运行的进程信息
    
    unpause   Unpause a paused container                    # 取消暂停容器
    
    version   Show the docker version information           # 查看 docker 版本号
    
    wait      Block until a container stops, then print its exit code   # 截取容器停止时的退出状态值

#### 6、Docker镜像 ####

##### 6.1 镜像的分层 #####

1.  分层的镜像
    
    我们的pull为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载  
    ![在这里插入图片描述][3a1eac06d5ff496eba6baba4212e56da.png]
2.  UnionFS（联合文件系统）
    
    UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
    
    特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
3.  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等等。
4.  重点理解
    
    **Docker镜像层都是只读的，容器层是可写的**
    
    当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。
    
    所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的。

##### 6.2 commit命令 #####

docker commit 提交容器副本使之成为一个新的镜像

docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
    
    # 案例演示Ubuntu安装Vim
    1、从Hub上下载Ubuntu到本地并成功运行
    2、原始默认的Ubuntu是不带vim命令 
    3、外网连通下，安装vim
       # 进入容器内部，更新包管理工具
       apt-get update
       # 然后安装我们所需的vim
       apt-get -y install vim
    4、安装完成后，在容器外 commit我们的新镜像
       docker commit -m="vim is ok " -a="2+3" f6720a2622c9 study/myubuntu:1.3

##### 6.3 总结 #####

Docker中的镜像分层，**支持通过扩展现有镜像，创建新的镜像**。类似Java继承于一个Base基础类，自己再按需扩展。

新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层

![在这里插入图片描述][b2a5331690cb4664a44a476b607af6f0.png]

#### 7、本地镜像发布 ####

##### 7.1 公有仓库 #####

本地镜像发布到阿里云

![在这里插入图片描述][8b97d7bce0284b38bd60082293c9fff4.png]

1.  镜像生成
    
    1.  基于当前容器创建一个新的镜像，功能增强
        
            docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]
    2.  docker file
2.  推送镜像至阿里云
    
    登录阿里云 - 控制台 - 容器镜像服务 - 实例列表 - 创建个人实例 - 创建命名空间 - 创建镜像仓库 - 管理
    
    从管理页面获取到 docker命令
3.  将镜像推送到Registry
    
        docker login --username=祁某某呀 registry.cn-hangzhou.aliyuncs.com
        docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/qixin_docker_demo/ubuntu_plus:[镜像版本号]
        docker push registry.cn-hangzhou.aliyuncs.com/qixin_docker_demo/ubuntu_plus:[镜像版本号]
4.  从Registry中拉去镜像
    
        docker pull registry.cn-hangzhou.aliyuncs.com/qixin_docker_demo/ubuntu_plus:[镜像版本号]

##### 7.2 私有仓库 #####

官方Docker Hub地址：https://hub.docker.com/，中国大陆访问太慢了且准备被阿里云取代的趋势，不太主流。

Dockerhub、阿里云这样的公共镜像仓库可能不太方便，涉及机密的公司不可能提供镜像给公网，所以需要创建一个本地私人仓库供给团队使用，基于公司内部项目构建镜像。

Docker Registry是官方提供的工具，可以用于构建私有镜像仓库

1.  下载镜像 Docker Registry
    
        docker pull registry
2.  运行私有库 Registry，相当于本地有个私有 Docker Hub
    
        # 默认情况，仓库被创建在容器的/var/lib/registry目录下，建议自行用容器卷映射，方便于宿主机联调
        docker run -d -p 5000:5000  -v /mydata/myregistry/:/tmp/registry --privileged=true registry
3.  案例演示：Ubuntu安装ifconfig命令并提交
    
    docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:\[标签名\]
    
        1、从Hub上下载Ubuntu到本地并成功运行
        2、原始默认的Ubuntu是不带 ifconfig 命令 
        3、外网连通下，安装ifconfig
           # 进入容器内部，更新包管理工具
           apt-get update
           # 然后安装我们所需的vim
           apt-get install net-tools
        4、安装完成后，执行 ifconfig 进行测试
        5、安装完成后，在容器外 commit我们的新镜像
           docker commit -m="ubuntu add ifconfig is ok " -a="2+3" 9cc27010ad9b myubuntuifconfig:1.4
4.  curl验证私服库中镜像列表
    
        curl -XGET http://192.168.88.129:5000/v2/_catalog
        
        # 返回 {"repositories":[]}
        #可以看到，目前私服库没有任何镜像上传过。。。。。。
5.  上传至私服库
    
        docker tag myubuntuifconfig:1.4 192.168.88.129:5000/myubuntuifconfig:1.4
        
        按照公式： docker   tag   镜像:Tag   Host:Port/Repository:Tag
        # 使用命令 docker tag 将zzyyubuntu:1.2 这个镜像修改为192.168.88.129:5000/zzyyubuntu:1.2
        # docker tag myubuntuifconfig:1.4 192.168.88.129:5000/myubuntuifconfig:1.4
6.  修改配置文件使之支持http
    
        # docker默认不允许http方式推送镜像，通过配置选项来取消这个限制
        vim /etc/docker/daemon.json
        
        {
              
          "registry-mirrors": ["https://zkplqh8u.mirror.aliyuncs.com"],
          "insecure-registries": ["192.168.88.129:5000"]
        }
        
        # 重启docker
        systemstl restart docker
        # 启动本地私服
        docker run -d -p 5000:5000  -v /mydata/myregistry/:/tmp/registry --privileged=true registry
7.  push推送到私服库
    
        docker push 192.168.88.129:5000/myubuntuifconfig:1.4
8.  pull从私服库拉去镜像
    
        docker pull 192.168.88.129:5000/myubuntuifconfig:1.4

#### 8、容器数据卷 ####

##### 8.1 注意！！！ #####

在docker挂载时，在挂载目录后多加一个\*\*–privileged=true\*\*参数

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

如果是CentOS7安全模块会比之前系统版本加强，不安全的会先禁止，所以目录挂载的情况被默认为不安全的行为，

在SELinux里面挂载目录被禁止掉了额，如果要开启，我们一般使用–privileged=true命令，扩大容器的权限解决挂载目录没有权限的问题，也即

使用该参数，container内的root拥有真正的root权限，否则，container内的root只是外部的一个普通用户权限。

##### 8.2 数据卷 #####

1.  概念
    
    将docker容器内的数据保存到宿主机的磁盘中
    
        # 运行一个带有容器卷存储功能的容器实例
        docker run -it --privileged=true -v/宿主机绝对路径目录:/容器内目录 镜像名
2.  作用
    
    将运用与运行的环境打包镜像，run后形成容器实例运行 ，但是我们对数据的要求希望是持久化的
    
    Docker容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据自然也就没有了。
    
    为了能保存数据在docker中我们使用卷。
3.  特点
    
    1.  数据卷可在容器之间共享或重用数据
    2.  卷中的更改可以直接实时生效，爽
    3.  数据卷中的更改不会包含在镜像的更新中
    4.  数据卷的生命周期一直持续到没有容器使用它为止

##### 8.3 数据卷案例 #####

1.  命令
    
        docker run -it --privileged=true -v/宿主机绝对路径目录:/容器内目录 镜像名
2.  查看数据卷是否挂载成功
    
        docker inspect 容器ID
        
        # 查看显示
                "Mounts": [
                    {
              
                        "Type": "bind",
                        "Source": "/mydata/ubuntu/opt",
                        "Destination": "/opt",
3.  容器与宿主机之间数据共享
    
    1.  docker修改，主机同步获得
    2.  主机修改，docker同步获得
    3.  docker容器stop，主机修改，docker容器重启看数据是否同步

##### 8.4 读写规则映射添加说明 #####

1.  读写（默认）
    
        docker run -it --privileged=true -v/宿主机绝对路径目录:/容器内目录:rw 镜像名
2.  只读
    
        # 容器实例内部被限制，只能读取不能写
        docker run -it --privileged=true -v/宿主机绝对路径目录:/容器内目录:ro 镜像名
3.  卷的继承和共享
    
        # 容器1完成和宿主机的映射
        docker run -it --privileged=true -v/宿主机绝对路径目录:/容器内目录 镜像名
        
        # 容器2继承容器1的规则   docker run -it --privileged=true --volumes-from practical_banzai --name u2 ubuntu
        docker run -it --privileged=true --volumes- from 父类 --name="u2"

#### 9、Docker上常规软件安装 ####

搜索镜像–拉取镜像–查看镜像–启动镜像–停止镜像–移出容器

##### 9.1 安装tomcat #####

1.  docker hub上查找tomcat镜像
    
        docker search tomcat
2.  从docker hub上拉取镜像到本地
    
        docker pull tomcat
3.  docker images查看是否拉取到镜像
    
        docker images
4.  使用镜像创建容器实例
    
        # 运行镜像
        docker run -it -p 8080:8080 tomcat
        
        # 参数说明：
        -p：小写，宿主机端口:容器内端口
        -P：大写，随机分配端口
        i:交互
        t:终端
        d:后台
5.  访问 ip:端口 ，查看是否启动成功
    
        # 确保防火墙开放8080端口，若没有，则执行开放
        firewall-cmd --zone=public --add-port=8080/tcp --permanent
        systemctl restart firewalld.service
         
        # 访问出现404，进入容器内部，执行命令
        [root@localhost /]# docker exec -it 9bd4dbe6e8cc bash
        root@9bd4dbe6e8cc:/usr/local/tomcat# ls
        BUILDING.txt  CONTRIBUTING.md  LICENSE  NOTICE  README.md  RELEASE-NOTES  RUNNING.txt  bin  conf  lib  logs  native-jni-lib  temp  webapps  webapps.dist  work
        root@9bd4dbe6e8cc:/usr/local/tomcat# rm -r webapps
        root@9bd4dbe6e8cc:/usr/local/tomcat# mv webapps.dist webapps
        root@9bd4dbe6e8cc:/usr/local/tomcat#

![在这里插入图片描述][a70122c4bce74c719749539dccf5e158.png]

1.  免修改版本
    
        # 拉取镜像
        docker pull billygoo/tomcat8-jdk8
        # 启动
        docker run -d -p 8080:8080 billygoo/tomcat8-jdk8

##### 9.2 安装mysql #####

###### 简单版 ######

1.  下载镜像
    
        docker pull mysql:5.7
2.  查看镜像
    
        docker images
3.  运行镜像实例
    
        docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
4.  查看容器是否启动
    
        docker ps
5.  进入数据库
    
        # 进入容器
        docker exec -it ac55ae7bc126 bash
        # 进入数据库
        mysql -uroot -p123456
        # 数据库操作 创建库表后， 执行插入带中文数据语句报错
        SQL 错误 [1366] [HY000]: Incorrect string value: '\xE5\xBC\xA0\xE4\xB8\x89' for column 'name' at row 1
        # 原因 ： docker上默认字符集编码隐患
6.  查看字符集编码
    
        docker里面的mysql容器实例查看，内容如下：
        SHOW VARIABLES LIKE 'character%'

![在这里插入图片描述][071a5018c61c479aae07b385bdc67832.png]

1.  存在问题
    
    容器删除后，相关数据随之删除。。。。。。

###### 实战版 ######

1.  新建mysql容器实例
    
        docker run -d -p 3306:3306 --privileged=true \
        -v /mydata/mysql/log:/var/log/mysql \
        -v /mydata/mysql/data:/var/lib/mysql \
        -v /mydata/mysql/conf:/etc/mysql/conf.d \
        -e MYSQL_ROOT_PASSWORD=123456  \
        --name mysql \
        mysql:5.7
2.  新建my.cnf配置文件
    
        vim /mydata/mysql/conf/my.cnf
        # 输入配置信息
        [client]
        default_character_set=utf8
        [mysqld]
        collation_server = utf8_general_ci
        character_set_server = utf8
        
        # 重启mysql容器，并查看字符集编码
        docker restart mysql
        # mysql内查看字符集编码
        SHOW VARIABLES LIKE 'character%'
        # 新插入带中文数据语句测试后无误
3.  结论
    
    docker安装完MySQL并run出容器后，建议请先修改完字符集编码后再新建mysql库-表-插数据

##### 9.3 安装redis #####

1.  拉取镜像
    
        docker pull redis:6.0.8
2.  宿主机新建目录
    
        mkdir /mydata/redis
3.  宿主机新建配置文件
    
        vim /mydata/redis/redis.conf
        
        # 配置信息
        1、开启redis登录验证
            requirepass 123
        2、允许redis外地连接
            注释掉 # bind 127.0.0.1
        3、修改 daemonize 
        	daemonize no
        4、开启redis数据持久化
        	appendonly yes
4.  运行镜像
    
        docker run  -p 6379:6379 --name redis --privileged=true \
        -v /mydata/redis/redis.conf:/etc/redis/redis.conf \
        -v /mydata/redis/data:/data \
        -d redis:6.0.8 redis-server /etc/redis/redis.conf
5.  测试使用redis-cli连接
    
        # 连接redis
        docker exec -it redis redis-cli
        # 登录
        auth your_password
6.  验证配置文件是否生效
    
        # 测试redis
        127.0.0.1:6379> set a b
        OK
        127.0.0.1:6379> get a
        "b"
        127.0.0.1:6379> select 15
        OK
        127.0.0.1:6379[15]> select 16
        (error) ERR DB index is out of range
        # 修改 /mydata/redis/redis.conf 验证配置文件是否生效
        databases 10
        # 退出redis并重启redis容器，重新连接至redis
        127.0.0.1:6379[15]> select 15
        (error) ERR DB index is out of range
        # 可见配置文件已生效

[043daeced26a4866b6018baed31d1965.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2b1197f063774e8385381b05e42df74d.png
[3a1eac06d5ff496eba6baba4212e56da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a94508073e354b75bb9670aa8db3e314.png
[b2a5331690cb4664a44a476b607af6f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3e22c0ee3f1d481184e279f239feef70.png
[8b97d7bce0284b38bd60082293c9fff4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/22b6bc1d65414382ab7a2a9cce399fc6.png
[a70122c4bce74c719749539dccf5e158.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e9ce95063a46450ba204d48d0206d7f6.png
[071a5018c61c479aae07b385bdc67832.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e08e040623564d4aadb2e50d0c238fab.png