Docker学习

Docker学习

1 Docker介绍

1.1 安装

wget http://fishros.com/install -O fishros && . fishros  # 一件安装

1.2 架构

• 镜像（Image）：Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。
• 容器（Container）：**镜像（Image）和容器（Container）**的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是利用镜像创建运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
• 仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

1.3 配置加速器

阿里云

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

网易云

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["http://hub-mirror.c.163.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

2 Docker命令

2.1 进程命令(daemon)

# 1 启动docker服务:
systemctl start docker

# 2 停止docker服务:
systemctl stop docker

# 3 重启docker服务:
systemctl restart docker

# 4 查看docker服务状态:
systemctl status docker

# 5 设置开机启动docker服务:
systemctl enable docker

2.2 镜像命令

1 docker images

# 1 查看镜像: 查看本地所有的镜像
docker images
docker images –q  # 查看所用镜像的id

:~/WPJ$ sudo docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    9c7a54a9a43c   4 months ago   13.3kB
# 仓库下镜像		版本		镜像ID		创建时间		  大小

2 docker search

# 2 搜索镜像:从网络中查找需要的镜像
docker search 镜像名称

3 docker pull

# 拉取镜像: 从Docker仓库下载镜像到本地，镜像名称格式为 名称:版本号，如果版本号不指定则是最新的版本。如果不知道镜像版本，可以去docker hub 搜索对应镜像查看。
docker pull 镜像名称:版本号

docker pull redis:5.0
sudo docker pull shanmukhananda/orb-slam2:latest

docker镜像

4 docker rmi

docker rmi 镜像id # 删除指定本地镜像
docker rmi `docker images -q` # 删除所有本地镜像  docker images -q是列出所有 镜像的id

docker rmi redis:latest

2.3 容器命令

1 创建容器

# 创建并启动容器
docker run 参数
参数说明：
• -i：保持容器运行。通常与 -t 同时使用。加入it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭。
• -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用。
• -d：以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用docker exec 进入容器。退出后，容器不会关闭。
• -it 创建的容器一般称为交互式容器，-id 创建的容器一般称为守护式容器
• --name：为创建的容器命名。

实验1

  这样创建容器后会直接进入容器，下面实验首先拉取镜像，然后利用拉取的镜像创建容器！

docker run -it --name=xxx 镜像名:版本号  /bin/bash
docker run -it --name=orb shanmukhananda/orb-slam2:latest  /bin/bash

  创建好的容器就像是一个纯净的Linux系统。

实验2

  以后台模式运行容器。创建一个容器在后台运行(不会直接进入容器)，需要使用docker exec 进入容器。退出后，容器不会关闭!

docker run -id --name=orb 镜像名:版本号  /bin/bash
docker run -id --name=orb shanmukhananda/orb-slam2:latest  /bin/bash

2 查看容器

# 查看容器
docker ps # 查看正在运行的容器
docker ps –a # 查看所有容器
docker ps –aq # 查看所有容器的ID

3 进入容器

  只可进入未关闭容器，如果容器关闭，则需要重启容器！

# 进入容器
docker exec [OPTIONS] 容器名 COMMAND [ARG...]


Options:
  -d, --detach               Detached mode: run command in the background
      --detach-keys string   Override the key sequence for detaching a container
  -e, --env list             Set environment variables
      --env-file list        Read in a file of environment variables
  -i, --interactive          Keep STDIN open even if not attached
      --privileged           Give extended privileges to the command
  -t, --tty                  Allocate a pseudo-TTY
  -u, --user string          Username or UID (format: "<name|uid>[:<group|gid>]")
  -w, --workdir string       Working directory inside the container


# 进入orb容器————只能进入没有关闭的容器，正在运行
docker exec -it orb /bin/bash

4 退出容器

exit # 退出容器，容器不会关闭

5 停止容器

# 停止容器，容器关闭，非运行状态
docker stop 容器名称

6 启动容器

# 启动容器
docker start 容器名称

必须启动容器后才能进入容器，否则会报错

7 删除容器

# 删除容器：如果容器是运行状态则删除失败，需要停止容器才能删除
docker rm 容器名称

docker stop $(docker ps -aq)	
docker rm $(docker ps -aq)		# 删除所有容器

 
docker rm 容器ID  # 也可以通过ID来删除

8 查看容器

# 查看容器信息
docker inspect 容器名称

3 Docker容器数据卷

3.1 数据卷概念

  数据卷是宿主机中的一个目录或文件（虚拟机中一个目录或文件）

• 当容器目录和数据卷目录绑定后，对方的修改会立即同步
• 一个数据卷可以被多个容器同时挂载
• 一个容器也可以被挂载多个数据卷

  这里宿主机认为虚拟机，外部机器即windows，数据卷的一个作用就是方便了通信与数据交换，就算容器被删除，数据也不会丢失，因为删除容器不会删除宿主机中的数据！

3.2 配置数据卷

3.2.1 容器与宿主机

# 创建启动容器时，使用 –v 参数 设置数据卷
docker run -it --name=orb 镜像民:版本号 –v 宿主机目录( 文件):容器内目录( 文件) ...

# 实验
~$ docker run -it --name=ORB-SLAM 
-v /home/wheeltec-client/WPJ/docker_data:/home/wpj/data shanmukhananda/orb-slam2:latest /bin/bash

3.2.2 容器与容器

  其实就是在创建这个容器时候，为其挂载相同的目录。

~$ docker run -it --name=a 
-v xxx:xxx shanmukhananda/orb-slam2:latest /bin/bash

~$ docker run -it --name=b 
-v xxx:xxx shanmukhananda/orb-slam2:latest /bin/bash

3.3 数据卷容器

1. 创建启动c3数据卷容器，使用 –v 参数 设置数据卷

docker run -it --name=c3 -v /WPJ/docker_data shanmukhananda/orb-slam2:latest /bin/bash   

2. 创建启动 c4 c5 容器，使用 –-volumes-from 参数 设置数据卷

docker run -it --name=c4 --volumes-from c3 shanmukhananda/orb-slam2:latest /bin/bash

docker run -it --name=c5 --volumes-from c3 shanmukhananda/orb-slam2:latest /bin/bash

5 Dockerfile镜像原理

  这里由3个问题引出docker镜像的本质，Docker镜像是由特殊的文件系统叠加而成。

• Docker 镜像本质是什么？（文件系统）

• Docker 中一个centos镜像为什么只有200MB，而一个centos操作系统的iso文件要几个G？（docker的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层）

• Docker 中一个tomcat镜像为什么有500MB，而一个tomcat安装包只有70多MB？（由于docker中镜像是分层的，tomcat虽然只有70多MB，但他需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat镜像大小500多MB）

5.1 关于操作系统

一个操作系统主要由以下几个系统组成，这里只需关注文件管理子系统。

• 进程调度子系统
• 进程通信子系统
• 内存管理子系统
• 设备管理子系统
• 文件管理子系统
• 网络通信子系统
• 作业控制子系统

​ Linux文件系统由bootfs和rootfs两部分组成

1 bootfs：包含bootloader（引导加载程序）和 kernel（内核）

2 rootfs： root文件系统，包含的就是典型 Linux 系统中的/dev，/proc，/bin，/etc等标准目录和文件

​ 不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等，所以这里也说明为什么部署linux系统占用空间小。因为相同的部分直接用宿主机代替，只是部署了不同的文件如rootfs。

5.2 Docker 镜像原理

  Docker镜像是由特殊的文件系统叠加而成。最底端是 bootfs，并使用宿主机的bootfs，第二层是 root文件系统rootfs,称为基础镜像base image。

  然后再往上可以叠加其他的镜像文件，统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在。

  在用户的角度看来，只存在一个文件系统。一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像成为基础镜像rootfs。当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器

5.3 制作镜像

5.3.1 方法1：容器转为镜像

docker commit 容器id 镜像名称: 版本号
docker save -o 称 压缩文件名称 镜像名称: 版本号
docker load –i 压缩文件名称

5.3.2 方法2：dockerfile

① 关键字作用

  Dockerfile 是一个文本文件，包含了一条条的指令，每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于那个image构建
MAINTAINER	作者信息	用来标明这个dockerfile谁写的
LABEL	标签	用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN	执行命令	执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,“param2”]
CMD	容器启动命令	提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,“param2”]
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中会使用
COPY	复制文件	build的时候复制文件到image中
ADD	添加文件	build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
ENV	环境变量	指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
ARG	构建参数	构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME	定义外部可以挂载的数据卷	指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME [“目录”]
EXPOSE	暴露端口	定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR	工作目录	指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
USER	指定执行用户	指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK	健康检查	指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
ONBUILD	触发器	当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL	发送信号量到宿主机	该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL	指定执行脚本的shell	指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

② 案例1：发布springboot项目

案例需求：定义dockerfile，发布springboot项目

  首先将要封装的那个程序包放入到对应的文件夹，然后在该文件夹里面创建名为fff的dockerfile文件。

FROM java:8		# 定义父镜像
MAINTAINER pj	# 定义作者信息
ADD springboot.jar app.jar	# 将jar包添加到容器
CMD java –jar app.jar		# 定义容器启动执行的命令

1 通过dockerfile构建镜像：docker bulid –f dockerfile对应路径 –t 镜像名称:版本

2 通过这个镜像创建新的容器docker run -id 镜像名：版本号，这里系统会自动给新建的容器起名

③ 案例2 ：制作Ubuntu20.04镜像

案例需求：自定义centos7镜像。要求：

1. 默认登录路径为 /usr
2. 可以使用vim

  centos7是一种linux系统，一般是企业使用。这里制作ubuntu镜像，因为本质上一样，且对Ubuntu更加熟悉！下面是完整的dockerfile文件

# 使用Ubuntu 20.04作为基础镜像
FROM ubuntu:20.04
LABEL maintainer="2976394767@qq.com"

# 设置非交互式前端以避免交互式提示
ENV DEBIAN_FRONTEND=noninteractive

# 更新包列表并安装需要的软件包
RUN apt-get update && \
    apt-get install -y \
    curl \
    build-essential \
    wget \
    mlocate \
    libeigen3-dev \
    cmake \					# 下面这两个库都是安装Pagolin需要的库文件
    libgl1-mesa-dev \		# OpenGL扩展库   
    libglew-dev \			# GLEW库，OpenGL扩展库
    git \
    && apt-get clean

# 克隆Pangolin的0.5版本并编译安装
RUN git clone https://github.com/stevenlovegrove/Pangolin.git /opt/Pangolin && \
    cd /opt/Pangolin && \
    git checkout tags/v0.5 && \ 
    mkdir -p /opt/Pangolin/build && \
    cd /opt/Pangolin/build && \
    cmake .. && \
    make -j$(nproc) && \
    make install

WORKDIR /home/pj

CMD /bin/bash

执行dockerfile文件

docker bulid –f dockerfile文件路径 –t 镜像名称:版本

docker build -f ./ubuntu_dockerfile -t myslam:1.0 .
# . 表示当前目录。这是告诉 Docker 在当前目录中查找 Dockerfile 文件并将其用作构建镜像的上下文（context）    镜像名和版本号是自己指定的

1 分析一些语法

sudo apt-get install -y packageName
# -y 选项将自动确认安装 packageName 软件包，而不需要用户手动输入 "yes" 或 "no" 来确认安装。

RUN apt-get update && \
    apt-get install -y \
    curl \
    wget \
    && apt-get clean这一段指令中，&&是什么意思  \是什么意思  
    
apt-get clean # 用于清理不必要的下载和缓存文件
&& # 是Linux命令行中的逻辑操作符，它表示只有前一个命令成功（退出状态码为0）时，才会执行后一个命令
\ # 反斜杠 \ 用于在Dockerfile中换行继续命令

build-essential 是一个包含了在Linux系统上进行软件编译和构建所需的基本工具和依赖项的元包（meta-package）。它是一个便于安装多个构建工具的软件包，通常用于开发环境中，以便用户能够编译和构建自己的程序或项目。

build-essential 包通常包括以下重要组件：

编译器：通常包括GNU C编译器（gcc）和GNU C++编译器（g++）。这些编译器用于将C和C++源代码编译成可执行文件。

构建工具：通常包括GNU Make工具（make），它用于自动化构建过程，例如编译、链接和安装。

库文件和头文件：虽然不是直接包含在build-essential中，但通常伴随着它的安装，包括一些基本的开发库文件和头文件，以便编译和链接软件时使用。

 make -j$(nproc)

$(nproc) 是一个用于获取可用CPU核心数量的命令。nproc 命令会返回系统中的CPU核心数量，然后这个值会被用于 make 命令中的 -j 参数，指示 make 并行编译的线程数量。这样可以加快编译速度，尤其是在多核处理器上。

/opt 给主机额外安装软件所摆放的目录

在Docker容器中通常不需要使用sudo来运行make install，因为Docker容器中的用户通常已经有了足够的权限来执行这些操作。Docker容器中的用户通常是root或具有sudo权限的用户。

CMD /bin/bash
# 用于指定在容器启动时要执行的默认命令，启动容器后会直接进入bash shell(终端)

2 利用这个镜像创建一个容器

docker run -it --name=test1 myslam:1.0 /bin/bash

因为WORKDIR /home/pj`，所以直接就在相应文件里。

在这个容器里面你可以自己安装任意的包，也可以源码编译，通过数据卷挂载。

6 Docker服务编排

6.1 服务编排概念

按照一定的业务规则批量管理容器

6.2 Docker Compose

  Docker Compose是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：

1. 利用 Dockerfile 定义运行环境镜像
2. 使用 docker-compose.yml 定义组成应用的各服务
3. 运行 docker-compose up 启动应用

6.2.1 安装Docker Compose

# Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version

6.2.2 卸载Docker Compose

# 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose

6.3 案例

用docker compose编排nginx+springboot项目

1. 创建docker-compose目录

mkdir ~/docker-compose
cd ~/docker-compose

2. 编写 docker-compose.yml 文件

version: '3'
services:
  nginx:
   image: nginx
   ports:
    - 80:80
   links:
    - app
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: app
    expose:
      - "8080"

3. 创建./nginx/conf.d目录

mkdir -p ./nginx/conf.d

4. 在./nginx/conf.d目录下 编写itheima.conf文件

server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}

5. 在~/docker-compose 目录下 使用docker-compose 启动容器

docker-compose up

6. 测试访问

http://192.168.149.135/hello

7 Docker私有仓库

7.1 私有仓库搭建

# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json   
vim /etc/docker/daemon.json    
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["私有仓库服务器ip:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

7.2 将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7
 
# 2、上传标记的镜像     
docker push 私有仓库服务器IP:5000/centos:7

7.3 从私有仓库拉取镜像

#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

8 Docker公共仓库

8.1 创建Docker Hub帐户

帐户

Username: pjdoctor
Password: xxx

8.2 登录到Docker Hub

$ docker login	# 终端输入

WARNING! Your password will be stored unencrypted in /home/wheeltec-client/.docker/config.json. Configure a credential helper to remove this warning. See https://docs.docker.com/engine/reference/commandline/login/#credentials-store

8.3 上传自建镜像

1. 标记镜像： 在推送之前，你需要为你的镜像添加一个标签，以包括Docker Hub的用户名和仓库名。

   docker tag 镜像名 your-docker-hub-username/镜像名
   
   docker tag myslam:1.0 pjdoctor/myslam:1.0
   

   在这里，your-docker-hub-username 是你在Docker Hub上的用户名。

2. 推送镜像： 使用以下命令将标记后的镜像推送到Docker Hub：

   docker push your-docker-hub-username/my-image
   
   docker push pjdoctor/myslam:1.0
   

3. 查看推送的镜像： 访问你的Docker Hub帐户，你将能够看到刚刚推送的镜像在你的仓库中。