# 方案一览





本篇博客将介绍如何在Docker容器中打开SSH连接服务，以及如何使用JetBrains Gateway软件进行代码调试。

## Gateway软件介绍

JetBrains Gateway是一款紧凑型桌面应用，可让您通过 JetBrains IDE 远程工作，甚至无需下载这些IDE。通过在桌面端安装这款软件，您可以直接调试服务器上的代码。

![JetBrains Gateway](/static/img/images/03665.png)

## 启动容器

使用以下命令启动容器，其中 `--net host` 参数是为了让容器使用宿主机的网络。

```bash
docker run -it --net host --gpus all kevinchina/deeplearning:cu11.8ubuntu22.04 bash
```

您也可以指定端口，比如将宿主机的2024端口映射到容器的22端口：

```bash
docker run -it -p 2024:22 --gpus all kevinchina/deeplearning:cu11.8ubuntu22.04 bash
```

## 配置apt源

详细配置apt源，请参考博客：[https://qq742971636.blog.csdn.net/article/details/134291339](https://qq742971636.blog.csdn.net/article/details/134291339)

对于Ubuntu 22.04，配置文件如下：

```bash
vim /etc/apt/sources.list
```

```bash
deb http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-security main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-updates main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-backports main restricted universe multiverse
## Pre-released source, not recommended.
# deb http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu/ jammy-proposed main restricted universe multiverse
```

## 在容器中安装SSH服务器

在容器内运行以下命令来安装SSH服务器，确保已经安装了openssh-server：

```bash
apt-get update
apt-get install -y openssh-server
```

## 配置SSH服务器

编辑SSH服务器配置文件 `/etc/ssh/sshd_config`，确保以下行被设置为合适的值：

```bash
Port 2024 # 根据需求设置，容器Linux开启SSH服务的默认端口是22
PermitRootLogin yes  # 允许root用户登录（可选，根据需要设置）
PasswordAuthentication yes  # 允许密码身份验证
```

## 生成SSH密钥

如果还没有SSH密钥对，可以生成一个：

```bash
ssh-keygen -t rsa -b 2048
```

## 启动SSH服务

启动SSH服务：

```bash
service ssh start
```

或者，如果容器中使用`systemd`，使用以下命令：

```bash
systemctl start ssh
```

## 为root创建密码

为root创建密码，例如设为 `nihao123`：

```bash
passwd root
nihao123
```

## 连接到容器

现在，可以使用SSH连接到Docker容器。在另一台服务器上执行以下命令：

```bash
ssh -p 2024 user@your_docker_host_ip
```

也可以直接使用root登录：

```bash
ssh -p 2024 root@101.20.31.31
```

请注意，出于安全考虑，建议使用SSH密钥进行身份验证，并将 `PasswordAuthentication` 设置为 `no`。确保防火墙允许通过所选的SSH端口的流量。


## 使用Gateway

这个就比较轻松了，别的服务器都可以ssh连接到容器里面了，此时，Gateway或者其他ssh工具就当然也是可以直接用ssh连接到容器中去。

【Python编程工具】【ssh连接Docker容器】如何使用Docker容器里的python环境，如何调试在容器中的代码

Docker 是一种轻量级的容器化技术，使得应用程序和它们的依赖可以被打包到一个容器中，方便在不同环境中运行。Dockerfile 是用于定义 Docker 镜像的文本文件，其中包含了一系列的指令，这些指令描述了镜像中应该包含哪些内容和如何配置。





![在这里插入图片描述](/static/img/images/03666.png)


## 1. 准备工作

在开始编写 Dockerfile 之前，确保你已经在系统中安装了 Docker。你可以从 [Docker 官方网站](https://www.docker.com/get-started) 获取安装步骤，或者阅读这里：[https://blog.csdn.net/x1131230123/article/details/118032295](https://blog.csdn.net/x1131230123/article/details/118032295)。

## 2. 创建 Dockerfile

首先，创建一个空的目录用于存放 Dockerfile 和相关文件。在该目录下创建一个文本文件并命名为 `Dockerfile`。

## 3. 编写基本结构

一个简单的 Dockerfile 通常包含以下基本结构：

```bash
# 使用基础镜像
FROM base_image:tag
# 维护者信息
MAINTAINER your_name
# 设置工作目录
WORKDIR /app
# 复制本地文件到容器中
COPY ./local_files /app
# 安装依赖
RUN apt-get update && apt-get install -y dependency_package
# 暴露端口
EXPOSE 8080
# 定义启动命令
CMD ["command_to_run"]
```

以上是一个简单的 Dockerfile，接下来我们逐步介绍每个指令的作用。

## 4. 指令详解

### FROM

`FROM` 指令用于指定基础镜像，即你的应用程序将在其基础上构建。可以选择官方镜像，也可以选择其他已有的镜像。例如：

```dockerfile
FROM ubuntu:20.04
```

### MAINTAINER

`MAINTAINER` 指令用于设置维护者的信息。

```dockerfile
MAINTAINER Your Name <your.email@example.com>
```

### WORKDIR

`WORKDIR` 指令用于设置工作目录，即在容器中执行后续指令时的工作目录。

```dockerfile
WORKDIR /app
```

### COPY

`COPY` 指令用于将本地文件复制到容器中。可以复制单个文件，也可以复制整个目录。

```dockerfile
COPY ./local_files /app
```

### RUN

`RUN` 指令用于在镜像中执行命令，例如安装依赖。

```dockerfile
RUN apt-get update && apt-get install -y dependency_package
```

### EXPOSE

`EXPOSE` 指令用于声明容器运行时将监听的端口。这只是一个元数据，实际运行时需要使用 `-p` 选项映射端口。

```dockerfile
EXPOSE 8080
```

### CMD

`CMD` 指令用于定义容器启动时执行的默认命令。

```dockerfile
CMD ["command_to_run"]
```

## 5. 实战演练

接下来，我们通过一个简单的 Node.js 应用演示如何编写 Dockerfile。

```dockerfile
FROM node:14
WORKDIR /app
COPY package.json package-lock.json /app/
RUN npm install
COPY . /app/
EXPOSE 3000
CMD ["npm", "start"]
```

在上述示例中，我们使用 Node.js 的官方镜像作为基础镜像，设置工作目录，复制 `package.json` 和 `package-lock.json` 安装依赖，复制所有文件到工作目录，声明监听端口为 3000，并定义启动命令为 `npm start`。

## 6. 构建镜像和运行容器

保存好 Dockerfile 后，可以使用以下命令构建镜像。在Docker中，`docker build -t my-node-app .` 中的小数点代表当前上下文的路径。这个路径是构建过程中 Docker 引擎查找 `Dockerfile` 和其他构建上下文的文件的位置。

具体来说，`docker build` 命令会将指定的路径（这里是小数点 `.`）作为构建上下文。构建上下文是构建过程中用来查找 `Dockerfile` 和其他构建文件的目录。在这个例子中，`.` 表示当前目录，即你运行 `docker build` 命令的目录。

当你运行 `docker build -t my-node-app .` 时，Docker 引擎会在当前目录下寻找 `Dockerfile` 文件，并将该目录及其所有内容作为构建上下文。这样，`Dockerfile` 就能够引用当前目录中的文件，并将它们添加到 Docker 镜像中。在给定目录之外的文件是不能通过Docker指令操作的，比如想用COPY去拷贝别的目录的文件到镜像中。

```bash
docker build -t my-node-app .
```

然后，可以运行容器：

```bash
docker run -p 3000:3000 my-node-app
```

现在，你的 Node.js 应用将在 Docker 容器中运行，并可以通过 [http://localhost:3000](http://localhost:3000) 访问。



 # `CMD` 和 `ENTRYPOINT` 之间的区别

## CMD 指令

`CMD` 指令用于定义容器启动时执行的默认命令。它有以下几种形式：

1. **CMD ["executable","param1","param2"] (exec 格式，推荐)**: 在指定的可执行文件内运行参数。

   

   ```dockerfile
   CMD ["npm", "start"]
   ```

2. **CMD ["param1","param2"] (作为 ENTRYPOINT 的默认参数)**: 提供给 ENTRYPOINT 指令的默认参数。

   

   ```dockerfile
   CMD ["npm", "start"]
   ```

3. **CMD command param1 param2 (shell 格式)**: 在 `/bin/sh -c` 中执行命令。

   ```dockerfile
   CMD npm start
   ```

`CMD` 的主要作用是为容器提供默认的执行命令，但可以被在运行容器时指定的命令覆盖。

## ENTRYPOINT 指令

`ENTRYPOINT` 指令用于配置容器启动时执行的默认可执行文件。它有以下几种形式：

1. **ENTRYPOINT ["executable", "param1", "param2"] (exec 格式，推荐)**: 在指定的可执行文件内运行参数。

   ```dockerfile
   ENTRYPOINT ["npm", "start"]
   ```

2. **ENTRYPOINT command param1 param2 (shell 格式)**: 在 `/bin/sh -c` 中执行命令。

   ```dockerfile
   ENTRYPOINT npm start
   ```

使用 `ENTRYPOINT` 的主要目的是将容器配置为像可执行程序一样运行。它的参数可以被 `CMD` 覆盖，但不会被完全替代。如果给 `docker run` 提供了参数，它们将追加到 `ENTRYPOINT` 的参数之后。

## 区别总结

- `CMD` 提供容器默认的执行命令，可以被运行容器时传入的命令覆盖。

- `ENTRYPOINT` 配置容器启动时执行的默认可执行文件，可以被运行容器时传入的命令追加到其参数之后。

综合来说，`CMD` 通常用于提供应用的默认启动命令，而 `ENTRYPOINT` 通常用于配置容器以类似可执行程序的方式运行。你也可以同时使用它们，以 `ENTRYPOINT` 提供基础执行文件，而 `CMD` 提供默认参数。

【Docker】如何编写Dockerfile，深入理解 Dockerfile：构建精简且高效的容器镜像

要删除所有没有名字的Docker镜像，您可以使用以下命令：





```bash
docker images -q -f dangling=true | xargs docker rmi
```

这个命令的步骤如下：

1. `docker images -q -f dangling=true`：该部分命令会列出所有没有名字（没有标签）的镜像的ID。 `-q` 标志表示只显示镜像ID，而不是完整的信息，而 `-f dangling=true` 表示只显示没有关联到任何容器的镜像。

2. `|`：这个符号是管道操作符，它将第一个命令的输出传递给下一个命令。

3. `xargs docker rmi`：`xargs` 命令将上一个命令的输出作为参数传递给 `docker rmi` 命令，从而删除这些镜像。

请注意，删除镜像是一个潜在的危险操作，因为这些镜像可能被其他容器使用。确保您真的希望删除这些没有名字的镜像，以避免对正在运行的容器产生负面影响。

Docker 如何删除所有没有名字的镜像

在Docker中，可以使用docker history命令查看镜像的历史记录。然而，默认情况下，docker history命令的输出是以简洁模式显示的，可能会省略一些细节。要显示更详细的信息，您可以使用docker history --no-trunc命令。这将显示完整的镜像历史记录，而不会进行任何截断或缩略。





以下是使用docker history --no-trunc命令的示例：

bash

```clike
docker history --no-trunc <IMAGE_ID>
```

将<IMAGE_ID>替换为您要查看历史记录的镜像的ID。执行此命令后，将显示完整的镜像历史记录，包括每个层的详细信息。

请注意，docker history命令还可以与其他选项一起使用，例如--quiet（仅显示镜像ID）或--format（使用自定义格式显示历史记录）。您可以根据需要进一步调整命令的输出。

如何让docker history出来的东西不缩略显示，不截断

有一个nfs盘挂载到本机，本机docker想用这个nfs盘存储。





此时docker自动用起了devicemapper 。

docker 用 devicemapper 这个后备存储有个默认卷的限制，是10g。现在都用overlay2了。

##  dd

解决，首先在nfs盘里面dd出一个500G大文件系统出来：
```
 dd if=/dev/zero of=/home/kevin_xie/yifeinfs/docker.data bs=1G count=500
```

```
dd 用来复制、抽取、转换文件，这里复制、抽取的大小可以以具体的块数指定，同时复制的时候可以进行编码或格式转换；
dd 的主要选项：
if=file                 输入文件名，这里的文件不能是目录；
of=file                输出文件名，这里的文件不能是目录；    
ibs=bytes         读入多少个字节，在这里就是指定块的大小，即输入缓冲区 的大小；
obs=bytes        一 次读入多少个字节，在这里就是指定块的大小，即输出缓冲区的大小；
bs=bytes          同时设置读写块的大小，可代替 ibs 和 obs；
cbs=bytes         一次转换多少个个字节，即转换缓冲区大；
skip=blocks      从输入文件开头跳过多少个块后再开始复制，也就是指定都从哪里开始复制；
seek=blocks     从输出文件开头跳过多少个块后再开始复制，也就是指定目的文件要空多少个块才开始写入(通常只有当输出文件是磁盘或磁带时才有效)
count=blocks     拷贝输入文件的多少个块；
conv=conversion[,conversion...]  指定格式转换的参数
ascii                转换 EBCDIC 为 ASCII；
ebcdic             转换 ASCII 为 EBCDIC；
ibm                  转换 ASCII 为 alternate EBCDIC；
block              把每一行转换为长度为 cbs 的记录，不足部分用空格填充；
unblock          使每一行的长度都为 cbs ，不足部分用空格填充；     
lcase               把大写字符转换为小写字符；
ucase              把小写字符转换为大写字符；
noerror            出错时不停止；
notrunc            不截断输出文件；
sync 把每个块都写满，数据不足的部分用空字符填充；
```

##  格式化dd出来的大文件

把大文件格式化为xfs文件系统：
```
mkfs.xfs docker.data
```


不小心弄错了就用这个指令强制覆盖成xfs文件系统：
```
 mkfs -t xfs -f docker.data
```

-t 　　 指定文件系统类型（如ext2，ext3，ext4等等），则会从/etc/mke2fs.conf文件中读取默认配置

-f 　　 强制覆盖


##  挂载

然后把这个大文件系统挂载到/var/lib/docker/下面去，之后在/var/lib/docker/产生的文件就会实际存储在docker.data里面去。
```
mount /home/kevin_xie/yifeinfs/docker.data /var/lib/docker/
```

![在这里插入图片描述](/static/img/images/00181.png)

Docker no space left on device 10G限制 nfs块 devicemapper

docker run 的时候增加参数 `--storage-opt size=30G`




```
docker run -it --gpus all --storage-opt size=30G kevinchina/deeplearning:cuda10.1pytorch1.7.1baseenv0.1 bash
```

> 设置容器磁盘大小 在 docker 启动时候 加载参数 --storage-opt dm.basesize=100G 用来调整默认容器的

> rootfs大小； 在创建容器的时候使用参数--storage-opt size=30G来设置改容器的 rootfs 大小。

> 

> 作者：momo1023 链接：https://www.jianshu.com/p/d984723d9b31 来源：简书

> 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

docker 容器 磁盘 10G 限制 大小

# cpu





miniconda3的一个基础镜像，其中安装fastapi和opencv。

kevinchina/deeplearning:miniconda3base0.2
```shell
FROM kevinchina/deeplearning:wrfbaseenv
COPY deps /deps
RUN rm -rf /etc/yum.repos.d/* && \
    cp /deps/CentOS-Base.repo /etc/yum.repos.d/ && \
    yum clean all
RUN yum install wget opencv -y
RUN wget http://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/conda.sh && \
    /bin/bash /tmp/conda.sh -b && \
    cp -f /deps/.condarc ~/ && rm /tmp/conda.sh
ENV PATH ~/miniconda3/bin:$PATH
RUN ~/miniconda3/bin/conda init bash && \
    . ~/.bashrc && \
    conda create -n py38 python=3.8.12 -y
RUN . ~/.bashrc && \
    conda activate py38 && \
    pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U && \
    pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && \
    pip install fastapi uvicorn python-multipart requests opencv-python numpy
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
```

在上一个基础上，安装pytorch cpu版本 1.8

kevinchina/deeplearning:miniconda3base0.3
```shell
FROM kevinchina/deeplearning:miniconda3base0.2
RUN . ~/.bashrc && conda activate py38 && conda install pytorch==1.8.0 torchvision==0.9.0 torchaudio==0.8.0 cpuonly -c pytorch
```

在上一个基础上，安装 yolo需求的包， 创建app文件夹。

成为 ： kevinchina/deeplearning:miniconda3base0.6
```
FROM kevinchina/deeplearning:miniconda3base0.3
RUN mkdir /app
WORKDIR /app
COPY requirements.txt .
COPY deps/Arial.ttf /root/.config/Ultralytics/Arial.ttf
RUN . ~/.bashrc && conda activate py38 && pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U
RUN . ~/.bashrc && conda activate py38 && pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
RUN . ~/.bashrc && conda activate py38 && pip install -r requirements.txt
```

```
matplotlib>=3.2.2
Pillow
PyYAML==5.3.1
scipy>=1.4.1
tqdm>=4.41.0
seaborn>=0.11.0
pandas
Shapely==1.8.0
numpy==1.19.2
tensorboard
```



# selenium

在kevinchina/deeplearning:miniconda3base0.2基础上装selenium

kevinchina/deeplearning:miniconda3base0.5
```shell
FROM kevinchina/deeplearning:miniconda3base0.2
RUN . ~/.bashrc && \
    conda activate py38 && \
    pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && \
    pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U && \
    pip install  pandas requests selenium
```



# GPU CUDA11.1  pytorch1.8

cuda11.1+pytorch1.8+opencv

kevinchina/deeplearning:cuda11.1pytorch1.8baseenv0.1
```shell
FROM kevinchina/deeplearning:cuda11.1pytorch1.8baseenv
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
```

下面是kevinchina/deeplearning:cuda11.1pytorch1.8baseenv0.5：

将目前YOLOv5需要的环境安装了起来。
```
FROM kevinchina/deeplearning:cuda11.1pytorch1.8baseenv0.1
RUN mkdir /app
WORKDIR /app
COPY requirements.txt .
RUN . ~/.bashrc && conda activate py38 && pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U
RUN . ~/.bashrc && conda activate py38 && pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
COPY deps/Arial.ttf /root/.config/Ultralytics/Arial.ttf
RUN . ~/.bashrc && conda activate py38 && pip install numpy==1.19.2 wandb  tensorboard -i https://pypi.tuna.tsinghua.edu.cn/simple
```

```
matplotlib>=3.2.2
Pillow
PyYAML==5.3.1
scipy>=1.4.1
tqdm>=4.41.0
seaborn>=0.11.0
pandas
Shapely==1.8.0
numpy==1.19.2
tensorboard
```

# GPU CUDA10.2 pytorch1.8

cuda10.2+pytorch1.8+opencv

kevinchina/deeplearning:cuda10.2pytorch1.8baseenv0.1
```shell
FROM nvidia/cuda:10.2-cudnn7-devel-centos7
COPY deps /deps
RUN rm -rf /etc/yum.repos.d/* && cp /deps/CentOS-Base.repo /etc/yum.repos.d/ && yum clean all
RUN yum install wget opencv vim -y
RUN wget http://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/conda.sh && \
    bash /tmp/conda.sh -b && rm /tmp/conda.sh && \
    cp -f /deps/.condarc /root/
RUN ~/miniconda3/bin/conda init bash && . ~/.bashrc && conda create -n py38 python=3.8.12 -y
RUN . ~/.bashrc && conda activate py38 && pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U && pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && pip install fastapi uvicorn python-multipart requests opencv-python numpy
RUN . ~/.bashrc && conda activate py38 && conda install pytorch==1.8.0 torchvision==0.9.0 torchaudio==0.8.0 cudatoolkit=10.2 -c pytorch -y
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
```

# GPU CUDA10.2   pytorch1.6.0

```shell
FROM nvidia/cuda:10.2-cudnn7-devel-centos7
COPY deps /deps
RUN rm -rf /etc/yum.repos.d/* && cp /deps/CentOS-Base.repo /etc/yum.repos.d/ && yum clean all
RUN yum install wget opencv vim -y
RUN wget http://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/conda.sh && \
    bash /tmp/conda.sh -b && rm /tmp/conda.sh && \
    cp -f /deps/.condarc /root/
RUN ~/miniconda3/bin/conda init bash && . ~/.bashrc && conda create -n py38 python=3.8.12 -y
RUN . ~/.bashrc && conda activate py38 && pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U && pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && pip install fastapi uvicorn python-multipart requests opencv-python numpy
RUN . ~/.bashrc && conda activate py38 && conda install pytorch==1.6.0 torchvision==0.7.0 cudatoolkit=10.2 -c pytorch
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
```


# GPU CUDA10.1 pytorch1.7.1

cuda10.1+pytorch1.7.1+opencv

kevinchina/deeplearning:cuda10.1pytorch1.7.1baseenv0.1

```shell
FROM nvidia/cuda:10.1-cudnn7-devel-centos7
COPY deps /deps
RUN rm -rf /etc/yum.repos.d/* && cp /deps/CentOS-Base.repo /etc/yum.repos.d/ && yum clean all
RUN yum install wget opencv vim -y
RUN wget http://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/conda.sh && \
    bash /tmp/conda.sh -b && rm /tmp/conda.sh && \
    cp -f /deps/.condarc /root/
RUN ~/miniconda3/bin/conda init bash && . ~/.bashrc && conda create -n py38 python=3.8.12 -y
RUN . ~/.bashrc && conda activate py38 && pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U && pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && pip install fastapi uvicorn python-multipart requests opencv-python numpy
RUN . ~/.bashrc && conda activate py38 && conda install pytorch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 cudatoolkit=10.1 -c pytorch -y
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
```

加一些库，加个VGG16的权重进去用。

kevinchina/deeplearning:cuda10.1pytorch1.7.1baseenv0.2
```
FROM kevinchina/deeplearning:cuda10.1pytorch1.7.1baseenv0.1
RUN . ~/.bashrc && conda activate py38 && pip install pymilvus pandas pillow clickhouse_driver opencv-python pillow requests
COPY vgg16-397923af.pth /root/.cache/torch/hub/checkpoints/
```

# YOLO

装了一些yolo的东西

kevinchina/deeplearning:cuda10.2torch1.8yolov0.1
```python
FROM kevinchina/deeplearning:cuda10.2pytorch1.8baseenv0.1
COPY requirements.txt .
COPY Arial.ttf /root/.config/Ultralytics/
RUN . ~/.bashrc && conda activate py38 && pip install -r requirements.txt
#pip install -r requirements.txt
# Base ----------------------------------------
matplotlib>=3.2.2
numpy>=1.18.5
Pillow
PyYAML==5.3.1
requests>=2.23.0
scipy>=1.4.1
tqdm>=4.41.0
pandas
requests
fastapi
uvicorn
python-multipart
seaborn>=0.11.0
pandas
Shapely==1.8.0
opencv-python
```

# paddle OCR 

docker push kevinchina/deeplearning:paddleocr0.1
```
FROM paddlepaddle/paddle:2.2.1
RUN rm -f /etc/localtime
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U
RUN pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
RUN pip install fastapi uvicorn python-multipart requests opencv-python numpy
RUN unset GREP_OPTIONS
COPY . /PaddleOCRAI
WORKDIR /PaddleOCRAI
RUN pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip install -r requirements.txt
RUN python setup.py install
#ENTRYPOINT nohup python ocr_fastapi_only_one.py >/ocr.log 2>&1 &
```

dockerfile 常用的环境编写 miniconda3 dockerfile python

dockerfile





COPY hl.tar.gz /wrf_env/

得到

```shell
(base) [root@fce482f7fc63 wrf_env]# ll
total 4
-rw-r--r--. 1 root root 143 Dec  9 03:35 hl.tar.gz
```

ADD hl.tar.gz /wrf_env1/

得到

```shell
(base) [root@fce482f7fc63 wrf_env1]# ll
total 0
drwxr-xr-x. 2 root root 24 Dec  9 03:32 test
(base) [root@fce482f7fc63 wrf_env1]# pwd
/wrf_env1
```

dockerfile ADD 和 COPY

centOS镜像的话，dockerfile 加一句：




```
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
```

Docker 容器内时区 时区对不上

[https://ivanzz1001.github.io/records/post/docker/2018/04/20/docker-harbor-architecture](https://ivanzz1001.github.io/records/post/docker/2018/04/20/docker-harbor-architecture)

Harbor整体架构

# 1docker login





去DockerHub官网建立帐号，然后创建仓库deeplearning。

本地使用docker login进行登陆。登陆成功有提示。

![在这里插入图片描述](/static/img/images/00215.png)

# 2 docker tag

更名

docker tag cpu:v1 kevinchina/deeplearning:cpuv1

# 3 docker push

上传

docker push kevinchina/deeplearning:cpuv1

等待即可：

![在这里插入图片描述](/static/img/images/00216.png)

# 阿里的Dockerhub

[https://cr.console.aliyun.com/#/imageList](https://cr.console.aliyun.com/#/imageList)

如何Docker push到DockerHub

参考：[https://blog.csdn.net/wenwenxiong/article/details/78728696](https://blog.csdn.net/wenwenxiong/article/details/78728696)





# 软链接

软链接的方式可以说是最简单最快捷最方便的方法，以后遇到这类问题都可以用这样去解决。

软件就是文件系统，docker的目录是/var/lib/docker，创建软链接让实际的文件存到别的地方，但相关系统变量都可以通过原路径/var/lib/docker访问。
```bash
# 停止docker
systemctl stop docker.socket
systemctl stop docker
# 移动docker所有文件
mv /var/lib/docker /home/docker
# 建立软连接
ln -s /home/docker/docker /var/lib/docker
# 重启docker
systemctl restart docker
```

![在这里插入图片描述](/static/img/images/00217.png)

【运维】Linux 修改Docker存储路径

如图所示，docker run -d -p 8080:8080 tomcat 启动tomcat服务。





然后docker logs 1ba487b1e2ca查看容器启动日志都没问题，但浏览器访问tomcat 8080就是出现404，且我的防火墙已经关闭。

![在这里插入图片描述](/static/img/images/00241.png)

经查验，解决方式需要 删除容器内的webapps空文件夹，然后把webapps.list改名为webapps，指令为：

```bash
docker exec -it 1ba487b1e2ca /bin/bash # 进入容器
rm -rf webapps # 删除
mv webapps.dist webapps # 重命名
```

![在这里插入图片描述](/static/img/images/00242.png)

再访问就OK了：

![在这里插入图片描述](/static/img/images/00243.png)

docker tomcat 容器 访问tomcat主页出现404提示

# 查看Docker存储位置





如此可以查看存储位置：
```csharp
sudo docker info | grep "Docker Root Dir"
```

# 使用软链接方式修改Docker存储位置

docker 的默认存储路径是/var/lib/docker，改成软链接即可。

```shell
# 关闭docker
sudo systemctl stop docker.socket
sudo systemctl stop docker
# 创建一个目录用于存储
mkdir -p /home/work/docker_root
# 移动文件
cp -R /var/lib/docker/* /home/work/docker_root
# 删除文件
rm -rf /var/lib/docker
# 增加软链接
ln -s /home/work/docker_root  /var/lib/docker
# 重启docker
sudo systemctl start docker
```

参考：[https://blog.csdn.net/BigData_Mining/article/details/104921479](https://blog.csdn.net/BigData_Mining/article/details/104921479)

Docker 修改 默认存储位置 存储空间不够

利用--shm-size参数：





```powershell
docker run -it --shm-size="6g" ubuntu
```

Docker ERROR: Unexpected bus error encountered in worker. This might be caused by insufficient share

## 1 需求





pytorch、tensorflow、mxnet等深度学习框架使用GPU的时候，不一样的版本会有一些CUDA要求，所以环境一直是困扰，Docker推出后，NVIDIA基于Docker给出解决方案，答案就是NVIDIA Container Toolkit。

github链接：

https://github.com/NVIDIA/nvidia-docker

架构图：

![在这里插入图片描述](/static/img/images/00345.png)

## 2 安装

### 2.1 安装前需要知道

我的机器是centOS 7，显卡是2080TI 11G，上面有GPU驱动和CUDA。

![在这里插入图片描述](/static/img/images/00346.png)

![在这里插入图片描述](/static/img/images/00347.png)




参考：[https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#install-guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#install-guide)

必须要有英伟达GPU驱动，版本大于等于418.81.07。

![在这里插入图片描述](/static/img/images/00348.png)

安装必要包：

```powershell
sudo yum install -y tar bzip2 make automake gcc gcc-c++ vim pciutils elfutils-libelf-devel libglvnd-devel iptables
```


### 2.2 安装Docker

这样：
```powershell
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 \
  device-mapper-persistent-data \
  lvm2
sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
sudo yum install docker-ce docker-ce-cli containerd.io -y
sudo systemctl start docker
sudo docker run hello-world
```


### 2.3 安装NVIDIA Container Toolkit

Setup the stable repository and the GPG key:

```powershell
distribution=$(. /etc/os-release;echo $ID$VERSION_ID) \
   && curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.repo | sudo tee /etc/yum.repos.d/nvidia-docker.repo
```

```powershell
sudo yum clean expire-cache
```

安装nvidia-docker2
```powershell
sudo yum install -y nvidia-docker2
```

重启
```powershell
sudo systemctl restart docker
```

听说Docker版本大于19，可以用`yum install -y nvidia-container-toolkit` 代替nvidia-docker2安装，我觉得都行。

安装nvidia-docker2后，可以`vim /etc/docker/daemon.json`看一下Docker的配置文件，是改写了的，重启Docker后生效了。

测试安装是否成功：

```powershell
docker run --rm --gpus all nvidia/cuda:10.1-base nvidia-smi
```

会看到：

![在这里插入图片描述](/static/img/images/00349.png)

## 3 总结

### 3.1 如何安装CUDA 11.0

官网安装后测试用的是CUDA11，我没有执行成功，那么如何才能成功？

```powershell
sudo docker run --rm --gpus all nvidia/cuda:11.0-base nvidia-smi
```

官网的GPU驱动版本是：

```powershell
NVIDIA-SMI 450.51.06    Driver Version: 450.51.06    CUDA Version: 11.0   
```

所以在官网查看GPU驱动和CUDA对应，找到了官网的兼容性介绍：

[https://docs.nvidia.com/deploy/cuda-compatibility/](https://docs.nvidia.com/deploy/cuda-compatibility/)

![在这里插入图片描述](/static/img/images/00350.png)

所以对于我来说，机器上的CUDA和cudnn不用改动，但我升级gpu driver是OK的，向下兼容，一直保持gpu driver是最新版本是OK的。

此外[Docker Hub](https://hub.docker.com/r/nvidia/cuda)的介绍也很明确，NVIDIA推出的镜像包含CUDA和cuDNN。

![在这里插入图片描述](/static/img/images/00351.png)

### 3.2 如何升级gpu driver？

首先搜索显卡能用得了的驱动：[https://www.nvidia.cn/Download/index.aspx?lang=cn#](https://www.nvidia.cn/Download/index.aspx?lang=cn#)，然后下载下来即可。

![在这里插入图片描述](/static/img/images/00352.png)

依次执行：

```powershell
chmod a+x NVIDIA-Linux-x86_64-465.31.run  #修改权限
./NVIDIA-Linux-x86_64-465.31.run --uninstall #卸载原有版本
NVIDIA-Linux-x86_64-465.31.run #安装新版本
```

### 3.3 升级gpu driver报错

报错：
```
An NVIDIA kernel module 'nvidia-uvm' appears to already be loaded in your kernel. This may be because it is in use (for example, by an X server, a CUDA program, or the NVIDIA Persistence Daemon), but this may also happen if your kernel was configured without support for module unloading. Please be sure to exit any programs that may be using the GPU(s) before attempting to upgrade your driver. If no GPU-based programs are running, you know that your kernel supports module unloading, and you still receive this message, then an error may have occurred that has corrupted an NVIDIA kernel module's usage count, for which the simplest remedy is to reboot your computer.
```

怎么办？

原因是卸载的时候有别的程序占用显卡不放，所以无法安装新的显卡驱动。先停止那些占用就可以了。

参见：[https://haoyu.love/blog549.html](https://haoyu.love/blog549.html)

依次执行：

```powershell
fuser -v /dev/nvidia* 
fuser -v /dev/nvidia* | grep -o -E '[0-9]+' | xargs kill -9
```

## 4 容器：深度学习环境

### 4.1 实践目标

目标，在容器里用conda安装上torch gpu 1.7.1：

```powershell
# CUDA 11.0
conda install pytorch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 cudatoolkit=11.0 -c pytorch
```

### 4.2 找到合适的devel镜像

NVIDIA发布的devel镜像在之前图看到过，里面包含了runtime，还有一些别的，相当于最全了！

找到镜像，[https://hub.docker.com/r/nvidia/cuda/tags?page=1&ordering=last_updated&name=11.0](https://hub.docker.com/r/nvidia/cuda/tags?page=1&ordering=last_updated&name=11.0)

pull镜像：
```powershell
docker pull nvidia/cuda:11.0.3-devel-centos7
```

dockerpull 过慢，给一个阿里镜像。

Docker阿里镜像：

[https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors](https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors)

### 4.3 运行容器

运行容器，用--gpus all参数去把宿主机资源带入容器中，此时nvidia-docker2在发挥作用：

```powershell
docker run -it -v /root:/define/root --gpus all 72978189a95a /bin/bash  # 运行镜像，挂载卷方便文件传输
```

yum没镜像寸步难行

yum给镜像方法是这样：

```powershell
mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
cd /etc/yum.repos.d/
wget http://mirrors.163.com/.help/CentOS7-Base-163.repo  # 配置为163源  可以不要这个 不执行这句
————————————————
版权声明：本文为CSDN博主「Q742971636」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/x1131230123/article/details/115007154
```

宿主机文件移动到/root,然后在容器内移动到/etc/yum.repos.d：

```powershell
cp /define/root/CentOS-Base.repo /etc/yum.repos.d
```

安装wget等工具：

```powershell
yum install -y wget vim git 
```

### 4.4 安装python

装miniconda：

```powershell
wget https://repo.anaconda.com/miniconda/Miniconda3-py38_4.9.2-Linux-x86_64.sh
sh Miniconda3-py38_4.9.2-Linux-x86_64.sh
source ~/.bashrc
```


装pytorch：

```powershell
# CUDA 11.0
conda install pytorch==1.7.1 torchvision==0.8.2 torchaudio==0.7.2 cudatoolkit=11.0 -c pytorch
```

### 4.5 用python程序测试环境

测试CUDA环境，写个py文件后执行，`touchtest.py`, `vim test.py` , 使用程序：

```python
import torch
flag = torch.cuda.is_available()
if flag:
    print("CUDA可使用")
else:
    print("CUDA不可用")
ngpu= 1
# Decide which device we want to run on
device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
print("驱动为：",device)
print("GPU型号： ",torch.cuda.get_device_name(0))
```

执行程序 `python test.py` 后看到：

![在这里插入图片描述](/static/img/images/00353.png)

好，这样就成功了，能在容器里使用GPU了！

## 5 开始使用

退出容器，docker ps -a找到刚才容器id，使用docker commit 把容器变成镜像：
```powershell
docker commit -a "Kevin" -m "cuda11 pytorch1.7.1" 529cfd575f70 cuda11pytorch1_7_1:v1
```

使用docker images查看生成的镜像：

![在这里插入图片描述](/static/img/images/00354.png)

以后就能使用这个镜像进行开发：
```powershell
docker run -it -v /root:/define/root --gpus all 1d5c02b61178 /bin/bash  # 运行镜像，挂载卷方便文件传输
```

更进一步把镜像保存为rar文件：

```powershell
docker save -o cuda11pytorch1_7_1.tar cuda11pytorch1_7_1:v1
```

加载本地镜像rar文件：

```powershell
docker load -i cuda11pytorch1_7_1.tar
```

Docker 搭建GPU容器用于深度学习 NVIDIA Container Toolkit CentOS 如何升级gpu driver

身在Docker容器里身不由己，wget能很好解决：





下载：
```powershell
wget https://repo.anaconda.com/miniconda/Miniconda3-py38_4.9.2-Linux-x86_64.sh
```

安装：

-b是静默安装，无需交互。
```powershell
sh Miniconda3-py38_4.9.2-Linux-x86_64.sh -b
```

所以记住这2个仓库：

[https://repo.anaconda.com/miniconda/](https://repo.anaconda.com/miniconda/)

[https://repo.anaconda.com/archive/](https://repo.anaconda.com/archive/)

Linux wget miniconda 快速安装miniconda环境

# Docker 入门指南







## 参考

- 菜鸟教程: [Docker 教程](https://www.runoob.com/docker/docker-tutorial.html)

- 狂神Docker笔记: [链接](https://blog.csdn.net/weixin_43591980/article/details/106272050?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162746190916780366597654%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=162746190916780366597654&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-1-106272050.pc_search_result_cache&utm_term=docker%20%E7%8B%82%E7%A5%9E&spm=1018.2226.3001.4187)

## 总览

Docker 的入门重点包括镜像命令学习、容器命令学习，之后学习 compose、网络。下面是关于 Docker 的一些图示：

![Docker总览图](/static/img/images/00361.png)

## Docker 安装

### centOS 安装

```bash
# 1. 卸载旧版本
yum remove docker \
    docker-client \
    docker-client-latest \
    docker-common \
    docker-latest \
    docker-latest-logrotate \
    docker-logrotate \
    docker-engine
# 2. 需要的安装包
yum install -y yum-utils
# 3. 设置镜像的仓库
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 推荐使用国内的
# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 4. 更新 yum 软件包索引
yum makecache fast
# 5. 安装 docker 相关的 docker-ce 社区版
yum install docker-ce docker-ce-cli containerd.io
# 6. 启动 docker
systemctl start docker
# 7. 使用 docker version 查看是否安装成功
docker version
# 8. 测试
docker run hello-world
```

### Ubuntu 安装方式

详见：[Ubuntu 安装方式](https://qq742971636.blog.csdn.net/article/details/134116129)

## 镜像命令

```powershell
docker images # 查看所有本地主机上的镜像，也可以使用 docker image ls 代替
docker search # 搜索镜像
docker pull # 下载镜像 docker image pull
docker rmi # 删除镜像 docker image rm
```

## 容器命令

```powershell
docker run 镜像id # 新建容器并启动 docker run -it centos /bin/bash
docker ps # 列出所有运行的容器 docker container list
docker rm 容器id # 删除指定容器
docker start 容器id # 启动容器
docker restart 容器id # 重启容器
docker stop 容器id # 停止当前正在运行的容器
docker kill 容器id # 强制停止当前容器
```

删除容器

```powershell
docker rm -f 容器id # 删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -rf
docker rm -f $(docker ps -aq) # 删除所有的容器
docker ps -a -q|xargs docker rm # 删除所有的容器
```

## 从压缩包加载镜像

使用 Docker 安装:

```bash
curl -fsSL https://get.docker.com | bash -s docker --mirror aliyun
```

拉取 Docker Hub 的镜像，最好在 Docker Hub 搜索后找到需要的镜像。加载本地镜像：

```bash
docker load -i wrf_v1.tar
```

后台运行镜像：

```bash
docker run –itd -v /home/wrf2/project10/data:/usr/ly/data -v /home/wrf2/project10/wrf_env/wrf_local/local:/usr/ly/local wrf:v1 /bin/bash
```

查看在运行的容器：

```bash
docker ps
```

查看所有容器，无论运行与否：

```bash
docker ps -a
```

进入一个正在运行的容器：

```bash
docker exec -it c42e6710b18e /bin/bash
```

要退出容器，且不让容器停止运行：

1. 先按快捷键 `ctrl+P`

2. 再按快捷键 `ctrl+Q`

## 容器 >> 镜像 >> 压缩包

将容器提交为镜像：

```powershell
docker commit -a "Kevin" -m "yolo" 73021fc5a50f yolov5image:v1
```

将镜像保存为

 RAR 压缩包：

```powershell
docker save -o my_ubuntu_v3.tar 794ee56580a5
```


# 清除掉状态是停止的容器

```bash
docker container prune
```


# 删除所有没有TAG的镜像

你可以使用 Docker 命令来删除没有 TAG 的镜像。以下是具体的命令：

```bash
docker rmi $(docker images -q -f dangling=true)
```

这个命令的含义是：

- `docker images`：列出所有镜像。

- `-q`：仅显示镜像 ID。

- `-f dangling=true`：过滤出没有 TAG 的镜像。

- `docker rmi`：删除选定的镜像。

这个命令将会删除所有没有 TAG 的镜像。

【运维】Docker 基本使用教程 dockerhub cookbook

组装：





```csharp
memset(send_zigbee, 0, sizeof(send_zigbee));
sprintf(send_zigbee, "YT%03d,%03d,%03d,%01d,%01d,%03d\n",
        (int) dis_hr,
        (int) dis_spo2,
        (int) temperature,
        (int) have_droplets,
        (int) rain,
        (int) departures);
USART3_SendString(send_zigbee);
```

解析：

```csharp
sscanf(rev_Slave_bufferdata, "YT%03d,%03d,%03d,%01d,%01d,%03d\n",
       &dis_hr,
       &dis_spo2,
       &temperature,
       &have_droplets,
       &rain,
       &departures);
```

C语言中的字符串组装与解析

VS2019正式版 密钥 Visual Studio 2019   Key





 

 企业版安装包：

链接：https://pan.baidu.com/s/1cdawgsIngBaMhA7sUVcGgg?pwd=hojb 

提取码：hojb 

Visual Studio 2019 Enterprise 企业版：

BF8Y8-GN2QH-T84XB-QVY3B-RC4DF

![在这里插入图片描述](/static/img/images/03937.png)



Visual Studio 2019 Professional 专业版：

NYWVH-HT4XC-R2WYW-9Y3CM-X4V3Y