# docker_learn

**Repository Path**: container_learn/docker_learn

## Basic Information

- **Project Name**: docker_learn
- **Description**: docker学习
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-07-16
- **Last Updated**: 2023-03-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Docker

官网：[Docker overview](https://docs.docker.com/get-started/overview/)

参考资料：[GitHub - yeasy/docker_practice: Learn and understand Docker&Container technologies, with real DevOps practice!](https://github.com/yeasy/docker_practice)



## 1. Docker概述

> Docker 是一个开源的应用容器引擎；可以实现虚拟化；复用操作系统的文件实现，启动快，占用体积小
>
> 组成：docker 仓库、镜像、容器、客户端

参考：[Docker 架构 | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-architecture.html)

## 2. Docker安装与启动

> 在线安装docker并使用命令启动、停止docker
>
> 1. 更新yum源为ustc；
>
> 2. 安装docker;
>
> 3. 更新docker的镜像源为ustc；
>
> 4. 使用docker命令操作docker
>
>    
>
> 启动>  systemctl start docker
>
> 停止>  systemctl stop docker
>
> 查看docker启动状态> systemctl status docker

### CentOS Docker 安装

>
>
>

参考：[CentOS Docker 安装 | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/centos-docker-install.html)

### Windows Docker 安装

> 基于WSL 子系统安装docker环境，
>
> 

参考：[Install Docker Desktop on Windows](https://docs.docker.com/desktop/install/windows-install/)



## 3. Docker常用命令

docker 运行镜像生成容器

```sh
docker run -it --privileged=true -d --restart=always --net host\
        --sysctl net.ipv4.tcp_fin_timeout=30\
        -e java_opts="-server -Xms4096m -Xmx4096m -Duser.timezone=GMT+08"\
        -e input_args="--spring.application.name=${SERVICE_ID}\ 
            --spring.cloud.nacos.config.server-addr=${NACOS_CONFIG_ADDR}\
            --spring.cloud.nacos.config.namespace=${NACOS_CONFIG_NAMESPACE}\ 
            --spring.cloud.nacos.config.username=${NACOS_USER_USERNAME}\
            --spring.cloud.nacos.config.password=${NACOS_USER_PASSWORD}\
            --server.port=35416"\
        -e health_check_opts="http://localhost:${SERVICE_PORT}/actuator/health start-period=45 interval=10 timeout=10 retries=3" ${IMAGE_NAME}
```



docker 容器排查问题-日志

```sh
docker logs -f --tail=100  CONTAINER
```

docker 容器排查问题-进入容器内部

```sh
docker exec -it CONTAINER  /bin/bash
```

docker 容器与主机之间的数据拷贝

```sh
# 容器内部文件拷贝到外部宿主机
docker cp CONTAINER:/work/logs/logback.log   /tmp

# 拷贝宿主机文件到容器中
docker cp /tmp/tmp.jar  CONTAINER:/work/
```

docker 将指定镜像保存成 tar 归档文件

```sh
docker save -o app.tar  IMAGE
```

docker 导入使用 [docker save](https://www.runoob.com/docker/docker-save-command.html) 命令导出的镜像

```sh
docker load < app.tar
```

docker 运行时容器打成镜像

```sh
docker export  -o app.tar  CONTAINER
```



参考：[Docker 命令大全 | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-command-manual.html)



## 4.Docker应用部署

#### mysql 部署

> 拉取mysql镜像，启动容器，操作容器中的mysql
>
> 步骤：
>
> 1. 拉取mysql镜像；
> 2. 创建并启动守护式容器；
> 3. 在容器中操作mysql；
> 4. 使用图形界面工具（windows）操作在docker中安装的mysql；在创建mysql容器的时候使用-p指定端口映射实现连接
>
> 在创建容器的时候指定环境变量MYSQL_ROOT_PASSWORD表示使用root进行远程连接时候的密码。如果需要进行远程连接的话可以使用-p进行端口映射。
>
> 参考：[Docker 安装 MySQL | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-install-mysql.html)



#### nginx 部署

> nginx的默认访问端口是：80；
>
> 如果被占用了80端口，那么在指定映射的时候可以改变宿主机的端口映射，在访问时也需要带上端口号
>
> 在创建容器的时候需要进行端口映射，指定-p，映射的端口80
>
> 1. 拉取nginx镜像；
> 2. 创建并启动nginx容器；
> 3. 在浏览器上访问容器中nginx，http://192.168.76.128
>
> 参考：[Docker 安装 Nginx | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-install-nginx.html)



#### redis 部署

> 拉取redis镜像，启动容器，操作容器中的redis
>
> 1. 拉取redis镜像；
>
> 2. 创建并启动redis容器；默认端口是6379，如果需要外部访问则可以使用端口映射；
>
> 3. 连接redis: ①使用命令行客户端 ②使用图形界面工具
>
>    
>
> 参考：[Docker 安装 Redis | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-install-redis.html)



## 5、Docker Compose

> docker-compose是一个应用工具；可以通过配置docker-compose.yml文件同时启动多个容器;
>
> 部署项目时可以编写一个docker-compose.yml文件作为启动项目单位，同时启动项目相关的那些容器
>
> 服务 ( service )：一个应用容器，实际上可以运行多个相同镜像的实例
>
> 项目 ( project )：由一组关联的应用容器组成的一个完整业务单元

参考：[Docker Compose | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-compose.html)

### 安装

>下载docker-compose二进制文件，赋予执行权限，配置环境变量即可
>
>1.下载：sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
>
>2.赋予可执行权限: sudo chmod +x /usr/local/bin/docker-compose
>
>

参考：[Overview (docker.com)](https://docs.docker.com/compose/install/)



### 实战

典型场景：**web网站**，包含如下部分：nginx、前端静态文件、springboot后台（依赖中间件：mysql、redis）

其中设计：

1. 容器固定ip，业务服务配置中间件容器ip即可
2. 将前端静态文件挂载到nginx容器静态文件夹中
3. 将mysql、redis、nginx 数据、配置文件进行挂载

   

|                | ip/端口          | 用户名/密码 |      | 注意事项                                        |
| -------------- | ---------------- | ----------- | ---- | ----------------------------------------------- |
| mysql          | 168.18.0.4:3306  | root/123456 |      | 如果需要持久化数据，需要将mysql数据挂载出来     |
| redis          | 168.18.0.6:6379  |             |      |                                                 |
| nginx          | 168.18.0.5:10086 |             |      | 将相关静态文件及端口转发配置挂载到nginx容器内部 |
| springboot后台 | 168.18.0.7:9090  |             |      |                                                 |
|                |                  |             |      |                                                 |



docker-compose.yml

```yaml
version: '3'

services:
  mysql:
     restart: always
     container_name: mysql
     image: mysql:5.7
     ports:
      - "3306:3306"
     volumes:
      - "/home/work/mysql/:/var/lib/mysql:rw"
     environment:
       MYSQL_ROOT_PASSWORD: 123456
     networks:
      credit-facility-net:
        ipv4_address: 168.18.0.4
  
  nginx:
    restart: always
    container_name: nginx
    image: nginx
    ports:
      - "10086:10086"
    volumes:
      - /home/work/nginx/demo-web/web.conf:/etc/nginx/conf.d/web.conf
      - /home/work/nginx/demo-web/dist:/usr/share/nginx/demo-web/
      
    networks:
      credit-facility-net:
        ipv4_address: 168.18.0.5
    depends_on:
      - server
  
  redis:
    restart: always
    container_name: redis
    image: redis:latest
    ports:
      - "6379:6379"
    volumes:
    networks:
      credit-facility-net:
        ipv4_address: 168.18.0.6  
  
  server:
    restart: always
    container_name: credit-facility-server
    image: springboot-demo:lastest 
    ports:
      - "9090:9090"
    volumes:
      - /home/work/server/application.yml:/work/application.yml
    networks:
      credit-facility-net:
        ipv4_address: 168.18.0.7  
    depends_on:
      - mysql
      - redis

# docker 网络
networks:
  credit-facility-net:
    driver: bridge
    ipam:
      config:
      - subnet: 168.18.0.0/24    
```



针对前端配置nginx配置（web.conf）如下： 

```conf
server {
        listen       10086;
        server_name  localhost;
		 
        location / {
            root   /usr/share/nginx/demo-web/;
            index  index.html index.htm;
        }

        location /api {
             # 后端服务地址
             proxy_pass  http://localhost:9090/api/;
             proxy_set_header Host $host:$server_port;
        }
    }   
```





部署步骤：

1. 创建docker 网络  ` docker network create credit-facility-net  `
2. 创建应用挂载文件夹
3. 服务全部拉起   `docker-compose up `
4. 服务验证，访问 ip:10086/index.html  查看页面数据



## 6、迁移与备份

> 将容器保存为镜像，备份，恢复镜像再启动以恢复的镜像作为基础的容器
>
> docker容器可以保存为一个镜像；备份为一个镜像包（*.tar）可以复制迁移到其他服务器，再恢复该tar包中的镜像，基于镜像运行容器实现环境的一致。

1. 将容器保存为一个镜像；命令：docker export
2. 备份镜像；命令：docker save
3. 恢复镜像；命令：docker load
4. 基于镜像运行容器；命令：docker run



## 7、Dockerfile

> 由一系列命令和参数构成的文本文件，实现基于基础镜像制作镜像
>
> 



#### 命令

> - FROM- 基础镜像，当前新镜像是基于哪个镜像的
>
> - MAINTAINER- 镜像维护者的姓名和邮箱地址
>
> - RUN- 容器构建时需要运行的命令
> - EXPOSE- 暴露端口
> - WORKDIR- 切换当前执行的工作目录
> - ENV- 用来在构建镜像过程中设置环境变量
> - ADD- 将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
> - COPY-  类似ADD，拷贝文件和目录到镜像中。
>   将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
> - VOLUME- 容器数据卷，用于数据保存和持久化工作
>
> - CMD- 容器启动的命令，如果有多个则以最后一个为准，也可以为ENTRYPOINT提供参数
> - ENTRYPOINT-  容器进入时执行的命令
> - ONBUILD - 当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发

参考：[Docker Dockerfile | 菜鸟教程 (runoob.com)](https://www.runoob.com/docker/docker-dockerfile.html)

最佳实践参考：[制作容器镜像的最佳实践 - 代码杂货铺 (xcodest.me)](https://xcodest.me/best-practices-for-building-docker-images.html)



#### 制作jdk1.8的镜像

> 1. 拉取centos7镜像；
>
> 2. 上传jdk1.8；
>
> 3. 编写Dockerfile文件；
>
> 4. 构建镜像；
>
> 5. 测试（基于新镜像创建并运行容器，运行java -version）
>
>    

本地文件： [Dockerfile](docker-profile\jdk-docker\Dockerfile) 

构建：` docker build -t  java:1.8 .`



#### 制作Springboot镜像

> 1. 使用上述jdk 1.8 镜像作为基础镜像
> 2. 编写Dockerfile文件；
> 3. 构建镜像；
> 4. 测试（基于新镜像创建并运行容器，运行java -version）

Dockerfile：

```Dockerfile
FROM java:1.8
MAINTAINER by lei

WORKDIR /work

# 添加微服务
ADD *.jar  app.jar

# 启动容器传入额外参数
#ENTRYPOINT ["/usr/bin/dumb-init", "--"]
CMD sh ./start.sh "${java_opts}" "${input_args}"
```

run.sh

```sh
#!/usr/bin/env bash

##虚拟机启动参数
java_opts=$1
##启动参数
input_args=$2


## log input elements
echo java_opts:[${java_opts}], input_args:[${input_args}]

#######################################################################
jar_name=app.jar


# 启动业务服务，非后台运行，让docker守护进程持续
java ${java_opts} -jar ./${jar_name} ${input_args} 

```



构建：` docker build -t  spring-demo:1.0.0 .`



## 8、Docker私有仓库

> 拉取、启动私有仓库镜像并可以访问私有仓库
>
> 拉取registry镜像；基于镜像创建私有仓库容器；需要去修改docker的一个配置文件指定私有仓库地址；再访问私有仓库。



#### 搭建&配置





#### 镜像上传私有仓库

> 将本地镜像打标签（标记本地镜像为一个私有仓库中的镜像）；将打了标签的镜像推送到私有仓库。



#### 私有仓库拉取镜像

> 私有仓库与拉取镜像的服务器是在同一台机器上：直接拉取镜像； `docker pull 私有仓库地址/镜像名称`
>
> 私有仓库与拉取镜像的服务器是不在同一台机器上：需要去修改docker的配置文件，指定私有仓库地址；再执行拉取镜像的命令。
>
> 如果本地存在同名的镜像需要先删除镜像后拉取