首页 > 其他分享 >docker笔记

docker笔记

时间:2022-11-24 16:55:59浏览次数:56  
标签:容器 -- jar ruoyi 笔记 mysql docker

一、docker简介

1.什么是docker

Docker 是一个开源的应用容器引擎,由于docker影响巨大,今天也用"Docker" 指代容器化技术。

2.docker的优势 一键部署,开箱即用 容器使用基于image镜像的部署模式,image中包含了运行应用程序所需的一切:代码、运行时、系统工具、系统库和配置文件。
无论是单个程序还是多个程序组成的复杂服务,或者分布式系统,都可以使用 docker run 或 docker compose up命令一键部署,省去了大量搭建、配置环境、调试和排查错误的时间。
一次打包,到处运行
Docker 为容器创建了行业标准,使容器成为了软件交付过程中的一种标准化格式,将软打包成容器镜(image),能够使软件在不同环境下运行一致,应用程序可以快速可靠地从一个环境移植到另外一个环境,并确保在所有的部署目标(例如开发、测试、生产环境)上都按预期运行,从而避免了“在我电脑上是好的,怎么到你那却不能用了?”的问题。

3.容器与虚拟机

容器包括应用程序及其所有依赖项。容器运行时,与宿主机共享操作系统内核,容器在linux内核层面(使用 Cgroupsnamespaces)来实现进程间的隔离,容器在主机操作系统上的用户空间中作为独立进程运行。
因此,容器相比于虚拟机更加轻量化,它体积小,启动快,占用资源少,性能好。
虚拟机使用虚拟化技术,应用程序运行在完整的操作系统(OS)之上,因此占用的资源更多,安装更复杂。
但是由于容器与宿主机共享内核,所以在隔离性和安全性方面不如虚拟机。

二、安装docker

1.Windows下安装Docker

  注意事项:
容器主要使用linux内核技术,因此Windows下安装docker可能会有遇到各种问题,建议刚入门的同学先在linux虚拟机里安装docker,学完之后在windows下安装,免得遇到问题后,还没入门就放弃了。

 

 

 

2.linux下安装Docker


安装环境:CentOS 7.3+
如果之前安装了旧版docker,请先删除。
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
安装仓库
sudo yum install -y yum-utils

sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
安装docker engine
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin
  启动docker,运行hello world查看是否成功
 
sudo systemctl start docker
sudo docker run hello-world
配置国内镜像仓库地址:
新建/etc/docker/daemon.json文件,输入如下内容:
{
  "registry-mirrors": [
    "https://registry.docker-cn.com",
    "http://hub-mirror.c.163.com",
    "https://fsp2sfpr.mirror.aliyuncs.com/"
  ]
}
然后重启,配置开机启动
sudo systemctl restart docker
sudo systemctl enable docker
sudo systemctl enable containerd

三、docker run 开箱即用

1.docker架构

  registry 镜像仓库
registry可以理解为镜像仓库,用于保存docker image。
Docker Hub 是docker官方的镜像仓库,docker命令默认从docker hub中拉取镜像。我们也可以搭建自己的镜像仓库。
image 镜像
image可以理解为一个只读的应用模板。image包含了应用程序及其所需要的依赖环境,例如可执行文件、环境变量、初始化脚本、启动命令等。
container 容器
容器是image的一个运行实例。当我们运行一个image,就创建了一个容器。


2.docker pull 拉取镜像

从镜像仓库拉取镜像到本地
docker pull nginx 不写默认是latest
docker pull nginx:latest
docker pull nginx:1.22
docker pull nginx:1.22.0-alpine
一般不建议使用latest,因为最新的镜像是滚动更新的,过一段时间,可能跟你本地的不是同一个。
使用docker images命令查看本地镜像

3.docker run 命令

docker run [可选参数] 镜像名:版本 []

公开端口:-p 宿主机ip:容器ip
docker run --name some-nginx -d -p 8080:80 nginx:1.22
默认情况下,容器无法通过外部网络访问。需要使用-p参数将容器的端口映射到宿主机端口,才可以通过宿主机IP进行访问。浏览器打开 http://192.168.56.106:8080
-p 8080-8090:8080-8090 公开端口范围,前后必须对应 -p 192.168.56.106:8080:80 如果宿主机有多个ip,可以指定绑定到哪个ip
  后台运行docker run --name db-mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 使用run命令,部署mysql,docker先去本地查找镜像,如果找不到,就去docker hub中拉取镜像   ●--name 定义容器的名称
  ●-e 声明环境变量
  ●-d容器在后台运行
  ●查看容器ip
docker inspect \
	--format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' db-mysql
可以使用以下命令操作容器:
docker start db-mysql 启动容器
docker stop 关闭容器
docker restart 重启容器
docker rm 删除容器
前台交互运行

创建一个新的容器,使用mysql客户端
docker run -it --rm mysql:5.7 mysql -h172.17.0.2 -uroot -p

-it 使用交互模式,可以在控制台里输入、输出
--rm在容器退出时自动删除容器。一般在使用客户端程序时使用此参数。
如果每次使用客户端都创建一个新的容器,这样将占用大量的系统空间。其中mysql -h172.17.0.2 -uroot -p 表示启动容器时执行的命令。

docker exec在运行的容器中执行命令,一般配合-it参数使用交互模式,docker exec -it db-mysql /bin/bash

常用命令: ●docker ps 查看正在运行的容器
●docker ps -a 查看所有容器,包括正在运行和停止的
●docker inspect 查看容器的信息
●docker logs查看日志
●docker cp 在容器和宿主机间复制文件
docker cp ./some_file 容器名:/work
docker cp 容器名:/var/logs/ /tmp/app_logs

四、docker 网络

 

默认网络

docker会自动创建三个网络,bridge,host,none


bridge桥接网络


如果不指定,新创建的容器默认将连接到bridge网络。
默认情况下,使用bridge网络,宿主机可以ping通容器ip,容器中也能ping通宿主机。
容器之间只能通过 IP 地址相互访问,由于容器的ip会随着启动顺序发生变化,因此不推荐使用ip访问。


host


慎用,可能会有安全问题。
容器与宿主机共享网络,不需要映射端口即可通过宿主机IP访问。(-p选项会被忽略)
主机模式网络可用于优化性能,在容器需要处理大量端口的情况下,它不需要网络地址转换 (NAT),并且不会为每个端口创建“用户空间代理”。


none


禁用容器中所用网络,在启动容器时使用。

用户自定义网络


创建用户自定义网络
docker network create my-net
将已有容器连接到此网络
docker network connect my-net db-mysql
创建容器时指定网络。
docker run -it --rm --network my-net mysql:5.7 mysql -hdb-mysql -uroot -p
在用户自定义网络上,容器之间可以通过容器名进行访问。
用户自定义网络使用 Docker 的嵌入式 DNS 服务器将容器名解析成 IP。

主机名解析

hostname
容器的hostname默认为容器的 ID。

docker run -it -d --hostname my-alpine --name my-alpine alpine:3.15

docker inspect \
	--format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' my-alpine

 /etc/hosts

在容器内手动修改/etc/hosts文件,容器重启后会恢复默认配置。
要是/etc/hosts修改生效,使用--add-host
docker run --add-host=my-alpine:172.17.0.3 -it --rm alpine:3.15

 五、docker存储

将数据存储在容器中,一旦容器被删除,数据也会被删除。同时也会使容器变得越来越大,不方便恢复和迁移。
将数据存储到容器之外,这样删除容器也不会丢失数据。一旦容器故障,我们可以重新创建一个容器,将数据挂载到容器里,就可以快速的恢复。

 存储方式

docker 提供了以下存储选项
 

volume 卷

卷存储在主机文件系统分配一块专有存储区域,由 Docker(在 Linux 上)管理,并且与主机的核心功能隔离。非 Docker 进程不能修改文件系统的这一部分。卷是在 Docker 中持久保存数据的最佳方式

bind mount 绑定挂载

绑定挂载可以将主机文件系统上目录或文件装载到容器中,但是主机上的非 Docker 进程可以修改它们,同时在容器中也可以更改主机文件系统,包括创建、修改或删除文件或目录,使用不当,可能会带来安全隐患

tmpfs 临时挂载

tmpfs挂载仅存储在主机系统的内存中,从不写入主机系统的文件系统。当容器停止时,数据将被删除。

绑定挂载(bind mount)

绑定挂载适用以下场景:
  ●将配置文件从主机共享到容器。
  ●在 Docker 主机上的开发环境和容器之间共享源代码或编译目录。
    ○例如,可以将 Maven 的target/目录挂载到容器中,每次在主机上用 Maven打包项目时,容器内都可以使用新编译的程序包。 -v
绑定挂载将主机上的目录或者文件装载到容器中。绑定挂载会覆盖容器中的目录或文件。如果宿主机目录不存在,docker会自动创建这个目录。但是docker只自动创建文件夹,不会创建文件。
例如,mysql的配置文件和数据存储目录使用主机的目录。可以将配置文件设置为只读(read-only)防止容器更改主机中的文件。
docker run -e MYSQL_ROOT_PASSWORD=123456 \
           -v /home/mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf:ro  \
           -v /home/mysql/data:/var/lib/mysql  \
           -d mysql:5.7 
 

tmpfs 临时挂载

临时挂载将数据保留在主机内存中,当容器停止时,文件将被删除。
docker run -d -it --tmpfs /tmp nginx:1.22-alpine

volume卷

卷 是docker 容器存储数据的首选方式,卷有以下优势:   ●卷可以在多个正在运行的容器之间共享数据。仅当显式删除卷时,才会删除卷。
  ●当你想要将容器数据存储在外部网络存储上或云提供商上,而不是本地时。
  ●卷更容易备份或迁移,当您需要备份、还原数据或将数据从一个 Docker 主机迁移到另一个 Docker 主机时,卷是更好的选择。 创建和挂载卷:
docker volume create my-data

docker run -e MYSQL_ROOT_PASSWORD=123456 \
           -v /home/mysql/conf.d/my.cnf:/etc/mysql/conf.d/my.cnf:ro  \
           -v my-data:/var/lib/mysql  \
           -d mysql:5.7 
创建nfs卷
docker volume create --driver local \
    --opt type=nfs \
    --opt o=addr=192.168.1.1,rw \
    --opt device=:/path/to/dir \
    vol-nfs

六、部署自己的应用

本例子我们使用docker来部署一个应用系统,RuoYi是一款用java编写的,基于SpringBoot+Bootstrap的后台管理系统。
ruoyi官方文档:http://doc.ruoyi.vip/ruoyi/
源码下载:https://gitee.com/y_project/RuoYi/tree/v4.7.4/

配置文件中修改了端口、数据库连接信息。
#application.yml文件
server:
  # 服务器的HTTP端口,默认为80
  port: 8080
  
  
  
#application-druid.yml文件
  url: jdbc:mysql://ruoyi-db:3306/ry?useUnicode=true&characterEncoding=utf8
  username: root
  password: 123456

将源码编译打包成ruoyi-admin.jar文件,放到宿主机/home/app目录下,/home/app/sql目录下放的是数据库初始化脚本。

●准备工作:
创建网络和存储卷
docker volume create ruoyi-data
docker network create ruoyi-net
部署mysql并初始化数据库,我们在创建数据库容器的时候,需要做三件事:
  ●创建数据库ry
  ●设置字符集为utf-8
  ●执行数据库初始化脚本
使用MYSQL_DATABASE环境变量创建数据库,设置字符集--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci,容器使用/docker-entrypoint-initdb.d目录下的脚本初始化数据库,脚本可以是.sh .sql.sql.gz这三种格式。
docker run -e MYSQL_ROOT_PASSWORD=123456 \
           -e MYSQL_DATABASE=ry \
           -v /home/app/sql:/docker-entrypoint-initdb.d \
           -v ruoyi-data:/var/lib/mysql  \
           --network ruoyi-net \
           --name ruoyi-db \
           -d mysql:5.7 \
           --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
部署应用
docker run -p 8080:8080 \
                    -v /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar \
                    --network ruoyi-net \
                    --name ruoyi-java \
                    -d openjdk:8u342-jre \
                    java -jar /usr/local/src/ruoyi-admin.jar
端口被some-nginx 占用,停掉nginx:docker stop some-nginx

容器名字重复,删掉该容器:docker rm ruoyi-java

解决乱码问题:
乱码问题是容器中mysql默认字符集引起的,我们需要将默认字符集改为utf8mb4。参考:https://github.com/docker-library/mysql/issues/131
可以进入容器,使用以下命令查看数据库字符集:
docker exec -it ruoyi-db mysql -uroot -p
>show variables like '%character%';
+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client     | latin1                     |
| character_set_connection | latin1                     |
| character_set_database   | utf8mb4                    |
| character_set_filesystem | binary                     |
| character_set_results    | latin1                     |
| character_set_server     | utf8mb4                    |
| character_set_system     | utf8                       |
| character_sets_dir       | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.03 sec)
  注意:由于删除容器不会删除存储卷,修改字符集需要删除存储卷,不然已经导入的数据字符集不会发生改变 删除容器和卷
docker stop ruoyi-db
docker rm ruoyi-db
docker volume rm ruoyi-data
可以通过以下两种解决方法:
1.修改运行参数
使用环境变量LANG=C.UTF-8设置客户端字符集
docker run  -e MYSQL_ROOT_PASSWORD=123456 \
            -e MYSQL_DATABASE=ry \
            -e LANG=C.UTF-8 \
            -v /home/app/sql:/docker-entrypoint-initdb.d \
            -v ruoyi-data:/var/lib/mysql  \
            --network ruoyi-net \
            --name ruoyi-db \
            -d mysql:5.7 \
            --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
或者
使用--skip-character-set-client-handshake忽略客户端字符集,使用客户端和服务端字符集一致 
docker run  -e MYSQL_ROOT_PASSWORD=123456 \
            -e MYSQL_DATABASE=ry \
            -v /home/app/sql:/docker-entrypoint-initdb.d \
            -v ruoyi-data:/var/lib/mysql  \
            --network ruoyi-net \
            --name ruoyi-db \
            -d mysql:5.7 \
            --skip-character-set-client-handshake --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci 
2.修改配置文件
修改/home/mysql/mysql.cnf
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci
init-connect='SET NAMES utf8mb4'

[client]
default-character-set=utf8mb4

[mysql]
default-character-set=utf8mb4
将配置文件挂载到容器中
docker run -e MYSQL_ROOT_PASSWORD=123456 \
           -e MYSQL_DATABASE=ry \
           -v /home/mysql/mysql.cnf:/etc/mysql/conf.d/mysql.cnf:ro  \
           -v /home/app/sql:/docker-entrypoint-initdb.d \
           -v ruoyi-data:/var/lib/mysql  \
           --network ruoyi-net \
           --name ruoyi-db \
           -d mysql:5.7

七、docker compose容器编排

在实际工作中,部署一个应用可能需要部署多个容器,一个一个部署非常不方便。docker compose可以一键部署和启动多个容器,它使用yaml文件来编排服务。
github和docker hub很多项目都提供了docker-compose.yaml文件,我们可以一键部署项目,非常方便。

一键部署wordpress

wordpress是一个著名的开源博客系统。
将以下内容保存到本地的docker-compose.yml文件中。
docker compose命令启动时,默认在当前目录下寻找compose.yamlcompose.yml
为了兼容之前的版本,也会查找docker-compose.yamldocker-compose.yml
也可以使用-f参数手动指定文件docker compose -f docker-compose-dev.yml up -d
version: '3.1'

services:

  wordpress:
    image: wordpress
    restart: always
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - wordpress:/var/www/html

  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - db:/var/lib/mysql

volumes:
  wordpress:
  db:
docker compose up -d一键部署启动
docker compose start/stop启动/停止服务
docker compose down停止并删除容器,不会删除存储卷volume

compose文件结构

docker-compose.yml通常需要包含以下几个顶级元素:
version 已弃用,早期版本需要此元素。
services必要元素,定义一个或多个容器的运行参数
services中可以通过以下元素定义容器的运行参数
   image 容器 镜像
  ports端口映射
  environment环境变量
  networks容器使用的网络
  volumes容器挂载的存储卷
  command容器启动时执行的命令
  depends_on定义启动顺序
复数形式(例如ports,networks,volumes,depends_on)参数需要传入列表
  networks创建自定义网络
  volumes 创建存储卷
    yaml文件语法   缩进代表上下级关系
  缩进时不允许使用Tab键,只允许使用空格
  :键值对,后面必须有空格
  -列表,后面必须有空格
  [ ]数组
  #注释
  {key:value,k1:v1}map
  | 多行文本块
如果一个文件中包含多个文档
  ---表示一个文档的开始
还有一种常见的用法:
把公共的配置提取出来,用&来建立锚点,<<合并到当前数据,用*引用锚点,例如
version: '3.7'

# Settings and configurations that are common for all containers
x-minio-common: &minio-common
  image: quay.io/minio/minio:RELEASE.2022-08-13T21-54-44Z
  command: server --console-address ":9001" http://minio{1...2}/data{1...2}
  expose:
    - "9000"
    - "9001"
  
services:
  minio1:
    <<: *minio-common
    volumes:
      - data1-1:/data1
      - data1-2:/data2

  minio2:
    <<: *minio-common
    volumes:
      - data2-1:/data1
      - data2-2:/data2

volumes:
  data1-1:
  data1-2:
  data2-1:
  data2-2:

编排自己的项目

以ruoyi项目为例子,先采用挂载目录的方式部署应用,等我们学完dockfile打包,就可以完整的部署应用了。
version: '3.1'

services:    

  ruoyi-app:
    #  docker run --name ruoyi-app      \
    #             -p 8080:8080        \
    #             --network ruoyi-net      \
    #             -v /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar   \
    #             -d openjdk:8u342-jre    \
    #             java -jar /usr/local/src/ruoyi-admin.jar
    image: openjdk:8u342-jre
    ports:
      - 8080:8080
    volumes:
      - /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar
    command: java -jar /usr/local/src/ruoyi-admin.jar
    networks:
      - ruoyi-net
    depends_on:
      - ruoyi-db
  
  ruoyi-db:
    #  docker run --name ruoyi-db -p 3303:3306 \
    #             --network ruoyi-net        \
    #             -v ruoyi-data:/var/lib/mysql  \
    #             -v /home/app/sql:/docker-entrypoint-initdb.d   \
    #             -e MYSQL_DATABASE=ry         \
    #             -e MYSQL_ROOT_PASSWORD=123456    \
    #             -d mysql:5.7      \
    #             --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --skip-character-set-client-handshake
    image: mysql:5.7
    environment: 
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=ry
    command: [
      "--character-set-server=utf8mb4",
      "--collation-server=utf8mb4_general_ci",
      "--skip-character-set-client-handshake"
      ]
    volumes:
      - /home/app/sql:/docker-entrypoint-initdb.d
      - ruoyi-data:/var/lib/mysql
    networks:
      - ruoyi-net
      
volumes:
  ruoyi-data:

networks:
  ruoyi-net:
command支持以下写法:
#推荐使用数组或列表的方式
#数组
command:
	["java",
  "-jar",
  "/usr/local/src/ruoyi-admin.jar"
	]
#列表
command: 
	- java
  - -jar
  - /usr/local/src/ruoyi-admin.jar

# shell命令模式
command: java -jar /usr/local/src/ruoyi-admin.jar
执行复杂的脚本
command:
  - bash
  - "-c"
  - |
    set -ex
    # Generate mysql server-id from pod ordinal index.
    [[ `hostname` =~ -([0-9]+)$ ]] || exit 1
    ordinal=${BASH_REMATCH[1]}
    echo [mysqld] > /mnt/conf.d/server-id.cnf
    # Add an offset to avoid reserved server-id=0 value.
    echo server-id=$((100 + $ordinal)) >> /mnt/conf.d/server-id.cnf
    # Copy appropriate conf.d files from config-map to emptyDir.
    if [[ $ordinal -eq 0 ]]; then
      cp /mnt/config-map/primary.cnf /mnt/conf.d/
    else
      cp /mnt/config-map/replica.cnf /mnt/conf.d/
    fi       
environment支持如下两种写法:
# 使用map
environment:
    MYSQL_DATABASE: exampledb
    MYSQL_USER: exampleuser
    MYSQL_PASSWORD: examplepass
    MYSQL_RANDOM_ROOT_PASSWORD: '1'

#使用列表
environment:
    - MYSQL_ROOT_PASSWORD=123456
    - MYSQL_DATABASE=ry
    - LANG=C.UTF-8

容器启动顺序depends_on

数据库初始化完成之前,不会建立connections。

depends_on只能保证容器的启动和销毁顺序,不能确保依赖的容器是否ready。
version: "3.9"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres
在这个例子中,depends_on只能保证web容器在db,redis之后启动,不会关注他们的状态是否启动完成或准备就绪。
要确保应用服务在数据库初始化完成后再启动,需要配合conditionhealthcheck使用。
services:
  web:
    build: .
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
  redis:
    image: redis
  db:
    image: postgres
condition有三种状态:
  service_started容器已启动
  service_healthy容器处于健康状态
  service_completed_successfully容器执行完成且成功退出(退出状态码为0)
我们来改造一下我们自己的docker-compose.yaml文件,完整例子如下:
services: 

  ruoyi-app:
    #  docker run --name ruoyi-app      \
    #             -p 8080:8080        \
    #             --network ruoyi-net      \
    #             -v /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar   \
    #             -d openjdk:8u342-jre    \
    #             java -jar /usr/local/src/ruoyi-admin.jar
    image: openjdk:8u342-jre
    restart: always
    ports:
      - 8080:8080
    networks:
      - ruoyi-net
    volumes:
      - /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar
    command: [ "java", "-jar", "/usr/local/src/ruoyi-admin.jar" ]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080"]
      interval: 5m30
      timeout: 5s
      retries: 5
      start_period: 20s
    depends_on:
      ruoyi-db:
        condition: service_healthy

  ruoyi-db:
    #  docker run --name ruoyi-db -p 3303:3306 \
    #             --network ruoyi-net        \
    #             -v ruoyi-data:/var/lib/mysql  \
    #             -v /home/app/sql:/docker-entrypoint-initdb.d   \
    #             -e MYSQL_DATABASE=ry         \
    #             -e MYSQL_ROOT_PASSWORD=123456    \
    #             -d mysql:5.7      \
    #             --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --skip-character-set-client-handshake
    image: mysql:5.7
    environment:
      - MYSQL_DATABASE=ry
      - MYSQL_ROOT_PASSWORD=123456
    volumes:
      - ruoyi-data:/var/lib/mysql
      - /home/app/sql:/docker-entrypoint-initdb.d
    networks:
      - ruoyi-net
    command:
      [
        "--character-set-server=utf8mb4",
        "--collation-server=utf8mb4_unicode_ci",
        "--skip-character-set-client-handshake"
      ]
    healthcheck:
      test: ["CMD", 'mysqladmin', 'ping', '-h', 'localhost', '-u', 'root', '-p$$MYSQL_ROOT_PASSWORD']
      interval: 5m
      timeout: 5s
      retries: 5
      start_period: 20s

volumes:
  ruoyi-data:

networks:
  ruoyi-net:

八、dockerfile制作镜像

dockerfile
dockerfile通常包含以下几个常用命令:
FROM ubuntu:18.04
WORKDIR /app
COPY . .
RUN make .
CMD python app.py
EXPOSE 80
FROM 打包使用的基础镜像
WORKDIR相当于cd命令,进入工作目录
COPY 将宿主机的文件复制到容器内
RUN打包时执行的命令,相当于打包过程中在容器中执行shell脚本,通常用来安装应用程序所需要的依赖、设置权限、初始化配置文件等
CMD运行镜像时执行的命令
EXPOSE指定容器在运行时监听的网络端口,它并不会公开端口,仅起到声明的作用,公开端口需要容器运行时使用-p参数指定。

制作自己的镜像

参考我们之前的配置,制作dockerfile文件
  ruoyi-java:
    image: openjdk:8u342-jre
    ports:
      - 8080:8080
    volumes:
      - /home/app/ruoyi-admin.jar:/usr/local/src/ruoyi-admin.jar
    command: [ "java", "-jar", "/usr/local/src/ruoyi-admin.jar" ]
    networks:
      - ruoyi-net
    depends_on:
      - ruoyi-db
编写dockerfile文件
FROM openjdk:8u342-jre
WORKDIR /app
COPY ./ruoyi-admin.jar .
CMD [ "java", "-jar", "ruoyi-admin.jar" ]
EXPOSE 8080
docker build . 打包     docker images 查看镜像id

docker tag 79d007b05ff6 ruoyi-app:4.7.4-jar 设置镜像的标签
 

image镜像与layer层

image文件由一系列层构建而成,dockerfile每一个命令都会生成一个层。每一层都是只读的。例如前面我们制作镜像,就产生了4个层。

也可以使用docker image history ruoyi-java:4.7.4命令查看
  创建容器时,会创建一个新的可写层,通常称为“容器层”。对正在运行的容器所做的所有更改(如写入新文件、修改现有文件和删除文件)都将写入容器层,而不会修改镜像。
 

多阶段构建

在构建基于 Java 的应用程序时,需要一个 JDK 将源代码编译为 Java 字节码。但是,在生产中不需要该 JDK。
多阶段构建可以将生成时依赖与运行时依赖分开,减小整个image文件大小。
 

Maven/Tomcat 示例

使用 Maven来构建应用,在最终的image中不需要包含maven。我们可以使用多阶段构建,每一个阶段从FROM开始,最终的image只会从最后一个阶段构建,不会包含前面阶段产生的层,因此可以减少镜像体积。
FROM maven AS build
WORKDIR /source
COPY . .
RUN mvn package

FROM  openjdk:8u342-jre
WORKDIR /app
COPY --from=build /source/ruoyi-admin/target/ruoyi-admin.jar .
EXPOSE 80
ENTRYPOINT ["java","-jar","ruoyi-admin.jar"]
docker build -t ruoyi-jar:4.7.4 .
version: '3.1'

services:

  ruoyi-java:
    image: ruoyi-jar:4.7.4
    command: [
      "--ruoyi.profile=/home/ruoyi/uploadPath",
      "--spring.datasource.druid.master.url=jdbc:mysql://ruoyi-db:3306/ry?useUnicode=true&characterEncoding=utf8",
      "--spring.datasource.druid.master.username=root",
      "--spring.datasource.druid.master.password=123456"
      ]
    ports:
      - 8080:8080
    networks:
      - ruoyi-net
    depends_on:
      - ruoyi-db

  ruoyi-db:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=ry
    command: [
      "--character-set-server=utf8mb4",
      "--collation-server=utf8mb4_general_ci",
      "--skip-character-set-client-handshake"
      ]
    volumes:
      - /home/app/sql:/docker-entrypoint-initdb.d
      - ruoyi-data:/var/lib/mysql
    networks:
      - ruoyi-net


volumes:
  ruoyi-data:

networks:
  ruoyi-net:

ENTRYPOINT和CMD的区别

dockerfile应该至少包含一个ENTRYPOINTCMD
ENTRYPOINT指定容器启动时执行的默认程序,一般运行容器时不会被替换或覆盖。
除非使用--entrypoint进行指定。
docker run -it --entrypoint /bin/bash redis 
CMD可以在启动容器时被替换和覆盖。
例如docker run -it --rm mysql:5.7 /bin/bash
如果镜像中ENTRYPOINTCMD都存在,则CMD将作为ENTRYPOINT的参数使用。

  参考: 视频教程 文档教程

标签:容器,--,jar,ruoyi,笔记,mysql,docker
From: https://www.cnblogs.com/lukelhi/p/16914303.html

相关文章