标签 Docker 下的文章

使用 Composerize 从 docker run 命令创建 Docker Compose 文件

如果你每天在正式或个人系统中使用 Docker,你应该知道有一个有用的应用叫 Composerize。在这个简短的指南中,我们将了解什么是 Composerize,以及如何使用 Composerize 在 Linux 中docker run 命令转换为 Docker Compose 文件格式。

什么是 Composerize?

Docker Compose 是一个用于定义和运行多容器 Docker 应用的工具。Docker Compose 只是一个 YAML 文件,我们在其中为 Docker 应用定义服务、网络和卷。

不是每个人都擅长写高效的 Docker Compose 文件。你们中的一些人可能会发现,甚至写一个简单的 Docker Compose 文件都很困难。不用担心! 看下 Composerize,它可以帮助你从 docker run 命令中创建 Docker Compose 文件。

Composerize 是一个命令行和基于网络的工具,可以将 docker run 命令转换成 Docker Compose 文件。

无论 docker run 命令是简单、简短还是冗长、复杂,都没有关系。你所要做的就是把命令传给 Conposerize。Composerize 会立即将 docker run 命令变成 Docker Compose 文件!

在 Linux 中安装 Composerize

Composerize 是作为一个网络服务提供的。所以你不需要在你的系统上安装它。如果你因为任何原因想在本地安装它,请继续阅读。

Composerize 可以用 npm 安装。确保你的系统中已经安装了 Nodejs。如果没有安装,请按照下面的链接来安装 Nodejs。

安装完 Nodejs 后,运行以下命令来安装 Composerize:

$ npm install composerize

该命令将只为当前用户安装 Composerize。

如果你想在全局(全系统)安装它,请运行上述命令并加上 -g 选项,如下所示。

$ npm install composerize -g

用 Composerize 将 Docker 命令转换为 Docker Compose 文件

要将 docker run 命令转换为 Docker Compose 格式,只需用 Composerize 运行它,如下所示:

$ composerize docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer

它将以 Docker Compose 文件格式生成内容。

示例输出:

version: '3.3'
services:
    portainer:
        ports:
            - '9000:9000'
        volumes:
            - '/var/run/docker.sock:/var/run/docker.sock'
        image: portainer/portainer

Convert Docker Run Commands Into Docker-Compose Files With Composerize

现在在你的 docker-compose.yml 文件中复制上面几行。就这么简单!

正如我所说,你也可以使用 Composerize 网络服务将 docker run 命令转换成 Docker Compose 格式。

进入 https://www.composerize.com/,将 docker run 命令粘贴到框中,你就会立即得到 docker-compose.yml 文件!

Turn Docker Run Commands Into Docker-compose Files Using Composerize

将命令转换为 Docker Compose 文件后,到你保存 docker-compose.yml 文件的位置,运行以下命令来启动 Docker 应用:

$ docker-compose up

Composerize 是对 Docker 用户有用的工具之一。你现在可以安全地告别漫无边际的 Docker 命令了。

资源:


via: https://ostechnix.com/convert-docker-run-commands-into-docker-compose-files/

作者:sk 选题:lkxed 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

使用 Watchtower 自动更新 Docker 容器基础镜像

对开发运维人员来说,保持 Docker 容器为最新版本是重要工作之一。手动更新 Docker 容器是一项耗时的工作。这篇文章解释了 Watchtower 是什么,如何安装它,以及在 Linux 中如何 使用 Watchtower 自动更新正在运行的 Docker 容器

Watchtower 是什么?

Watchtower 是一款自由开源的应用,用来监控运行中的 Docker 容器,并且当它发现基础镜像被更改后,可以自动的更新容器。

若 Watchtower 发现一个运行中的容器需要更新,它会以发送 SIGTERM 信号的方式,优雅的结束运行中容器的运行。

它会下载新镜像,然后以最初部署时使用的方式,重启容器。所有文件会在后台自动下载,因此不需要用户的介入。

在这份指南中,我们将会明白如何在类 Unix 系统中使用 Watchtower 自动更新正在运行的 Docker 容器。

我已经在 CentOS 和 Ubuntu 中测试了这份指南,所有的 Linux 发行版中操作过程都一样。

在 Linux 中安装 Watchtower

可以通过 Docker 镜像的方式下载 Watchtower 。因此,部署它是小事一桩。在你的 Linux 中安装 Docker 镜像,然后运行 Watchtower 立即开始监控 Docker 容器。

参考下方指导在基于 PRM 和 DEB 包管理系统中安装 Docker

安装 Docker 后,你可以使用以下命令以 root 用户身份部署 Watchtower 容器:

# docker run -d --name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower

如果你已经安装了 Docker 桌面版,以普通用户运行 Watchtower 容器。

$ docker run -d --name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower

该命令会拉取最新版的 watchtower 镜像,并运行 watchtower 容器。

输出样例:

Unable to find image 'containrrr/watchtower:latest' locally
latest: Pulling from containrrr/watchtower
1045b2f97fda: Pull complete 
35a104a262d3: Pull complete 
1a0671483169: Pull complete 
Digest: sha256:bbf9794a691b59ed2ed3089fec53844f14ada249ee5e372ff0e595b73f4e9ab3
Status: Downloaded newer image for containrrr/watchtower:latest
91c104ef0e9896e8cd5ff30d9f13e728dbfad66443830ec2ac85dde6d7d37564

Run Watchtower Docker Container

使用 Watchtower 自动更新 Docker 容器

在你的系统上,Watchtower 正在和其他容器一起运行。你可以使用一下命令查看运行中的 Docker 容器列表:

$ docker ps

输出样例:

CONTAINER ID   IMAGE                       COMMAND                  CREATED          STATUS          PORTS                                         NAMES
91c104ef0e98   containrrr/watchtower       "/watchtower"            14 minutes ago   Up 14 minutes   8080/tcp                                      watchtower
f90b462b0712   bitnami/wordpress-nginx:6   "/opt/bitnami/script…"   19 minutes ago   Up 19 minutes   0.0.0.0:80->8080/tcp, 0.0.0.0:443->8443/tcp   ostechnix-wordpress-1

正如上方输出所示,watchtower 容器正在和名为 ostechnix-wordpress-1 的容器一起运行。从现在开始,watchtower 会每隔几分钟会检查该容器。

如果 Watchtower 发现该容器的基础镜像的任何变化,它会优雅的关闭 ostechnix-wordpress-1 容器,然后使用与最初启动它时使用的相同方式,启动新的镜像。

类似的,它会自动地每隔几分钟检查所有的运行中容器,并自动更新它们。

Watchtower 如何更新多连接的容器?

在监视多连接容器时,Watchtower 十分智能。

假设我们现在运行两个容器。

$ docker ps

输出样例:

CONTAINER ID   IMAGE                       COMMAND                  CREATED          STATUS          PORTS                                         NAMES
91c104ef0e98   containrrr/watchtower       "/watchtower"            14 minutes ago   Up 14 minutes   8080/tcp                                      watchtower
f90b462b0712   bitnami/wordpress-nginx:6   "/opt/bitnami/script…"   19 minutes ago   Up 19 minutes   0.0.0.0:80->8080/tcp, 0.0.0.0:443->8443/tcp   ostechnix-wordpress-1
a895f082438a   bitnami/mariadb:10.6        "/opt/bitnami/script…"   20 minutes ago   Up 19 minutes   3306/tcp                                      ostechnix-mariadb-1

View Running Docker Containers

正如你看到的,我们正在运行 ostechnix-wordpress-1ostechnix-mariadb-1 这两个容器。ostechnix-mariadb-1 容器链接到 ostechnix-wordpress-1 容器。

如果 Watchtower 发现 ostechnix-wordpress-1 容器有个新版本,它会先关闭与之相连接的 ostechnix-mariadb-1 容器 ,然后才会关闭 ostechnix-wordpress-1 容器。

更新 ostechnix-wordpress-1 容器后,Watchtower 会以正确的顺序,且与最初启动它们时使用的相同方式,重启这两个容器,以便应用程序正确恢复。在我们的例子中,首先启动的是 ostechnix-mariadb-1 容器,然后是 ostechnix-wordpress-1 容器,以确保连接能够继续运行。

监控特定容器

默认情况下,Watchtower 将监控在它所指向的 Docker 守护进程中运行的所有 Docker 容器。

不过,你可以像下面这样,通过指定容器名称限制 Watchtower 监视特定的 Docker 容器。

$ docker run -d --name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower ostechnix-wordpress-1

在上方的例子中,watchtower 会忽略其他容器,只监视名为 ostechnix-wordpress-1 的容器更新情况。

如果你不指定任何参数,Watchtower 会照常监视所有运行中的 Docker 容器。

发送提示

或许你想收到容器更新的通知。你可以通过电子邮件、Slack 、MSTeams 以及 Gotify 发送通知。

下面这个例子展示了如何通过电子邮件发送通知。假设你已经设置了 SMTP 服务器。

docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -e WATCHTOWER_NOTIFICATIONS=email \
  -e [email protected] \
  -e [email protected] \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER=smtp.gmail.com \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PORT=587 \
  -e [email protected] \
  -e WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PASSWORD=app_password \
  -e WATCHTOWER_NOTIFICATION_EMAIL_DELAY=2 \
  containrrr/watchtower

参考下方 Watchtower Github 仓库和 Watchtower 官方主页获取更多信息:

资料


via: https://ostechnix.com/automatically-update-running-docker-containers/

作者:sk 选题:lkxed 译者:Donkey 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在这份指南中,我们将看到 Dockerfile 的简要介绍以及如何在 Linux 中使用 Dockerfile 来自动的 创建自定义 Docker 镜像

什么是 Dockerfile ?

Dockerfile 是附有构建 Docker 镜像说明的易于理解的文本文件。它囊括了用户在创建镜像时可以调用的所有命令。

我们可以使用 Dockerfile 创建自定义的镜像。可以通过 Docker Hub 分享的自定义 Docker 镜像。

如果你还不知道,Docker Hub 是 Docker 提供的托管存储库服务,用于团队查找和共享容器镜像,当然世界上任何人也都可以访问。

想象一下,早期如果我们想用 Nginx,我们要通过很多步骤,才能安装和配置好 Nginx 。得益于 Docker Hub ,现在我们可以在几分钟内,下载并运行 Nginx 的预置容器镜像。

Nginx Docker Image In Dockerhub

运行如下命令从 Docker Hub 上拉取 Nginx 镜像:

# docker pull nginx

一旦我们拉取了 Docker 镜像,可以运行如下命令使用它:

# docker run -it -d -p 8080:8080 nginx

就这样,十分简单!

参考下方链接,了解更多使用 Docker 的方式:

Docker Hub 上有超过十万个来自软件供应商、开源项目以及社区的容器镜像。

你可以从 Docker Hub 上下载你选择的镜像,并且使用上面的命令开始使用它。

理解 Dockerfile 格式

Docker 可以读取 Dockerfile 中的 指令 来自动的创建镜像。

典型的 Dockerfile 包含如下指令:

1、FROM —— 这会设置容器的基础镜像。

例如:

FROM ubuntu:22.04

这会将容器的基础镜像设置为 Ubuntu 。如果 ‘22.04’ 这个标志没有特别指明,则会设为最新版本(latest)。

2、LABEL —— 这是用来明确镜像的元数据信息的键值对。

例如:

LABEL ENV=“DEVELOPMENT”

3、RUN —— 这会在基础镜像中执行指令并创建一个新层。

例如:

RUN apt-get update
RUN apt-get install tomcat

4、CMD —— 这用来设置容器启动后先执行的命令。

例如:

CMD ["java", "-jar", "app.jar"]

5、EXPOSE —— 设置用于访问容器的端口。容器将会监听该端口。我们可以用来获得输出。

例如:

EXPOSE 8080

6、`MAINTAINER —— 显示创建镜像作者的信息。

例如:

MAINTAINER [email protected]

7、ENV —— 用来设置环境变量的键值对。这些变量在镜像创建的时候设置,并在容器创建好后可以使用。

例如:

ENV DB_NAME=”MySQL”
ENV DB_VERSION=”8.0”

8、COPY —— 用来拷贝本地文件至容器中。

例如:

COPY /target/devops.jar devops.jar

9、ADD —— 具有与拷贝相同的功能,不过更进一步还可以提取本地的 tar 文件或者从 URL 拷贝文件。

例如:

ADD devops.tar.xz / .
ADD http://example.com/abc.git /usr/local/devops/

10、ENTRYPOINT —— 用来设置镜像的主要命令。与 CMD 指令功能相同。不同的是 ENTRYPOINT 中的指令不会被重写。

例如:

ENTRYPOINT ["java", "-jar", "app.jar"]

11、VOLUME —— 该指令用来创建指定位置的挂载点。

例如:

VOLUME /app/devops

12、USER —— 将设置运行镜像并使用的用户名称以及用户组。

例如:

USER dhruv
USER admin

13、WORKDIR —— 这会设置工作目录。如果目录不存在,则会创建。

例如:

WORKDIR /var/lib/

这是一个 Dockerfile 的样本,可以参考一下:

FROM ubuntu:latest
MAINTAINER Senthilkumar Palani "[email protected]"
RUN apt-get install -y software-properties-common python
RUN add-apt-repository ppa:chris-lea/node.js
RUN echo "deb http://us.archive.ubuntu.com/ubuntu/ jammy universe" >>
/etc/apt/sources.list
RUN apt-get update
RUN apt-get install -y nodejs
RUN mkdir /var/www
ADD app.js /var/www/app.js
CMD ["/usr/bin/node", "/var/www/app.js"]

我将向你展示创建一个 Dockerfile 、创建并使用镜像的简单例子。

创建一个 Dockerfile

创建一个名为 dockerfile 的文件:

# nano dockerfile

添加下面几行命令。我们将更新并安装 vimcurl 包:

FROM alpine

RUN apk update
RUN apk add vim
RUN apk add curl

Dockerfile For Alpine Linux

按下 CTRL+OCTRL+X 键保存文件并关闭。

现在 Dockerfile 已经就位。让我们继续,用该 Dockerfile 创建一个镜像。

注意: 如果你在使用 Docker 桌面版,你可以以一个普通用户运行 docker 命令。

使用 Dockerfile 创建 Docker 镜像

只需运行以下命令,便可以使用 Dockerfile 创建 Docker 镜像:

# docker build -t alpine .

请注意最后有一个 .)。

输出示例:

[+] Building 51.2s (8/8) FINISHED                                               
 => [internal] load build definition from Dockerfile                       0.1s
 => => transferring dockerfile: 104B                                       0.0s
 => [internal] load .dockerignore                                          0.1s
 => => transferring context: 2B                                            0.0s
 => [internal] load metadata for docker.io/library/alpine:latest          38.8s
 => [1/4] FROM docker.io/library/alpine@sha256:7580ece7963bfa863801466c0a  2.7s
 => => resolve docker.io/library/alpine@sha256:7580ece7963bfa863801466c0a  0.0s
 => => sha256:d7d3d98c851ff3a95dbcb70ce09d186c9aaf7e25d48 1.47kB / 1.47kB  0.0s
 => => sha256:530afca65e2ea04227630ae746e0c85b2bd1a179379 2.80MB / 2.80MB  2.4s
 => => sha256:7580ece7963bfa863801466c0a488f11c86f85d9988 1.64kB / 1.64kB  0.0s
 => => sha256:9b2a28eb47540823042a2ba401386845089bb7b62a9637d 528B / 528B  0.0s
 => => extracting sha256:530afca65e2ea04227630ae746e0c85b2bd1a179379cbf2b  0.2s
 => [2/4] RUN apk update                                                   4.3s
 => [3/4] RUN apk add vim                                                  3.5s
 => [4/4] RUN apk add curl                                                 1.3s 
 => exporting to image                                                     0.4s 
 => => exporting layers                                                    0.4s 
 => => writing image sha256:14231deceb6e8e6105d2e551799ff174c184e8d9be8af  0.0s 
 => => naming to docker.io/library/alpine                                  0.0s 
                                                                                
Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them

按照上面的命令, Docker 会通过保存在当前工作目录中的 Dockerfile 中的命令开始自动的创建镜像。还记得我们在 Dockerfile 中保存的 apk updateapk add vimapk add curl 命令吗?这些命令也将会自动的执行。

如果 Dockerfile 保存在其他目录,你可以使用 -f 标志来指定路径,例如:

# docker build -f /path/to/a/Dockerfile .

创建好镜像后,我们可以使用如下命令运行它:

# docker run -it alpine

该命令会启动这个 Alpine 容器并连接到它。

/ # uname -a
Linux 8890fec82de8 5.10.104-linuxkit #1 SMP Thu Mar 17 17:08:06 UTC 2022 x86_64 Linux
/ # cat /etc/alpine-release 
3.16.1
/ #

如果你使用 Docker 桌面版,你可以通过 容器 Containers 标签页界面来查看运行中的容器。

View Containers In Docker Desktop

这就是使用 Dockerfile 构建自定义容器映像的方式。

我们仅仅讲了基础内容。你可以用 Dockerfile 做到很多东西。建议你参考一下官方 Dockerfile 参考 ,以了解更多内容。


via: https://ostechnix.com/a-brief-introduction-to-dockerfile/

作者:sk 选题:lkxed 译者:Donkey 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

在 Ubuntu 中使用 Docker Compose 安装 Docker 引擎的分步指导。

在这篇文章中,我们将会明白 Docker 是什么,如何 在 Ubuntu 中安装 Docker 引擎 。此外,我们也将会明白如何 安装 Docker Compose ,它是一个定义并运行多容器的 Docker 应用。

我们已经在 Ubuntu 22.04 LTS 中正式的测试了这份指南。然而,它也应该对旧版本如 20.04 LTS 和 18.04 LTS 有效。为了更好的安全性和稳定性,我推荐你使用最新的版本 —— Ubuntu 22.04 LTS 。

什么是 Docker ?

Docker 是一个快捷、轻便的系统级虚拟化技术,开发者和系统管理员可以使用它构建具备所有必要依赖项的应用程序,并将其作为一个包发布。

Docker 与其他如 VMWare 、Xen 、以及 VirtualBox 等工具的虚拟化方式不同,每个虚拟机不需要单独的客户操作系统。

所有的 Docker 容器有效地共享同一个主机系统内核。每个容器都在同一个操作系统中的隔离用户空间中运行。

Docker 容器可以在任何 Linux 版本上运行。比如说你使用 Fedora ,我用 Ubuntu 。我们能相互开发、共享并分发 Docker 镜像。

你无需担心操作系统、软件以及自定义设置,任何事都不用担心。只要我们的主机安装了 Docker ,就能持续开发。简言之,Docker 能够在任何地方运行!

前文中你读到了两个词:Docker 镜像Docker 容器 ,或许你在想它们的区别。

通俗地说,Docker 镜像是一个描述容器应该如何表现的文件,而 Docker 容器是 Docker 镜像的运行(或停止)状态。

希望你能够理解 Docker 的基础概念。更多细节,你可以参考文章末尾的 Docker 官方指导手册。

Docker 依赖项

为了安装并配置 Docker ,你的系统必须满足下列最低要求:

  1. 64 位 Linux 或 Windows 系统
  2. 如果使用 Linux ,内核版本必须不低于 3.10
  3. 能够使用 sudo 权限的用户
  4. 在你系统 BIOS 上启用了 VT(虚拟化技术)支持 on your system BIOS(参考: 如何查看 CPU 支持 虚拟化技术(VT)
  5. 你的系统应该联网

在 Linux ,在终端上运行以下命令验证内核以及架构详细信息:

$ uname -a

输出样例:

Linux Ubuntu22CT 5.15.35-3-pve #1 SMP PVE 5.15.35-6 (Fri, 17 Jun 2022 13:42:35 +0200) x86_64 x86_64 x86_64 GNU/Linux

正如上面你看到的那样,我的 Ubuntu 系统内核版本是 5.15.35-3-pve 并且系统架构是 64 位x86\_64 x86\_64 x86\_64 GNU/Linux)。

注意: 这里,我在 Proxmox 中使用 Ubuntu 22.04 容器。这是你看到上方内核版本中有 “pve” 字符的原因。如果你正在使用 Ubuntu 实体(或者虚拟)机,你将看到系统版本为 5.15.35-3-generic

内核版本需要不低于最低要求的版本,并且是 64 位机器。这样不会有任何问题,我们能顺利安装并使用 Docker 。

请注意你使用哪一个 Ubuntu 系统不重要。并且你使用 Ubuntu 桌面或服务器版本,亦或者其他 Ubuntu 变种如 Lubuntu 、Kubuntu 、Xubuntu ,都不重要。

只要你的系统内核版本不低于 3.10 ,并且是 64 位系统,Docker 都会正常运行。

在 Ubuntu 22.04 LTS 中安装 Docker

首先,更新你的 Ubuntu 系统。

1、更新 Ubuntu

打开终端,依次运行下列命令:

$ sudo apt update
$ sudo apt upgrade
$ sudo apt full-upgrade

2、添加 Docker 库

首先,安装必要的证书并允许 apt 包管理器使用以下命令通过 HTTPS 使用存储库:

$ sudo apt install apt-transport-https ca-certificates curl software-properties-common gnupg lsb-release

然后,运行下列命令添加 Docker 的官方 GPG 密钥:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

添加 Docker 官方库:

$ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

使用命令更新 Ubuntu 源列表:

$ sudo apt update

3、安装 Docker

最后,运行下列命令在 Ubuntu 22.04 LTS 服务器中安装最新 Docker CE:

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Install Docker In Ubuntu

当然你也可以安装其他版本 Docker 。运行下列命令检查可以安装的 Docker 版本:

$ apt-cache madison docker-ce

输出样例:

docker-ce | 5:20.10.17~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.16~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.15~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.14~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages
docker-ce | 5:20.10.13~3-0~ubuntu-jammy | https://download.docker.com/linux/ubuntu jammy/stable amd64 Packages

你可以挑选上面列表中的任何版本进行安装。例如,安装 5:20.10.16~ 3-0 ~ubuntu-jammy 这个版本,运行:

$ sudo apt install docker-ce=5:20.10.16~3-0~ubuntu-jammy docker-ce-cli=5:20.10.16~3-0~ubuntu-jammy containerd.io

安装完成后,运行如下命令验证 Docker 服务是否在运行:

$ systemctl status docker

你会看到类似下面的输出:

* docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2022-06-27 13:07:43 UTC; 3min 4s ago
TriggeredBy: * docker.socket
       Docs: https://docs.docker.com
   Main PID: 2208 (dockerd)
      Tasks: 8
     Memory: 29.6M
        CPU: 126ms
     CGroup: /system.slice/docker.service
             `-2208 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.071453522Z" level=info msg="ccResolverWrapper: sending update to cc: {[{unix:>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.071459974Z" level=info msg="ClientConn switching balancer to \"pick_first\"" >
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.130989294Z" level=info msg="Loading containers: start."
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.187439756Z" level=info msg="Default bridge (docker0) is assigned with an IP a>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.235966874Z" level=info msg="Loading containers: done."
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.240149866Z" level=warning msg="Not using native diff for overlay2, this may c>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.240281966Z" level=info msg="Docker daemon" commit=a89b842 graphdriver(s)=over>
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.240386856Z" level=info msg="Daemon has completed initialization"
Jun 27 13:07:43 Ubuntu22CT systemd[1]: Started Docker Application Container Engine.
Jun 27 13:07:43 Ubuntu22CT dockerd[2208]: time="2022-06-27T13:07:43.276336600Z" level=info msg="API listen on /run/docker.sock"

好极了!Docker 服务已启动并运行!

如果没有运行,运行以下命令运行 Docker 服务:

$ sudo systemctl start docker

使 Docker 服务在每次重启时自动启动:

$ sudo systemctl enable docker

可以使用以下命令查看已安装的 Docker 版本:

$ sudo docker version

输出样例:

Client: Docker Engine - Community
  Version:           20.10.17
  API version:       1.41
  Go version:        go1.17.11
  Git commit:        100c701
  Built:             Mon Jun  6 23:02:46 2022
  OS/Arch:           linux/amd64
  Context:           default
  Experimental:      true

Server: Docker Engine - Community
  Engine:
    Version:          20.10.17
    API version:      1.41 (minimum version 1.12)
    Go version:       go1.17.11
    Git commit:       a89b842
  Built:            Mon Jun  6 23:00:51 2022
    OS/Arch:          linux/amd64
    Experimental:     false
  containerd:
    Version:          1.6.6
    GitCommit:        10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
  runc:
    Version:          1.1.2
    GitCommit:        v1.1.2-0-ga916309
  docker-init:
    Version:          0.19.0
    GitCommit:        de40ad0

Check Docker Version

4、测试 Docker

让我们继续,测试 Docker 是否运行正常:

运行:

$ sudo docker run hello-world

上述命令会下载一个 Docker 测试镜像,并在容器内执行一个 “hello\_world” 样例程序。

如果你看到类似下方的输出,那么祝贺你!Docker 正常运行在你的 Ubuntu 系统中了。

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete 
Digest: sha256:13e367d31ae85359f42d637adf6da428f76d75dc9afeb3c21faea0d976f5c651
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Run Hello World Docker Container

很好!可以使用 Docker 了。

5、作为非 root 用户运行 Docker (选做)

默认情况下,Docker 守护进程绑定到 Unix 套接字而不是 TCP 端口。由于 Unix 套接字由 root 用户拥有,Docker 守护程序将仅以 root 用户身份运行。因此,普通用户无法执行大多数 Docker 命令。

如果你想要在 Linux 中作为非 root 用户运行 Docker ,参考下方链接:

我个人不这样做也不推荐你这么做。如果你不会在互联网上暴露你的系统,那没问题。然而,不要在生产系统中以非 root 用户身份运行 Docker 。

在 Ubuntu 中安装 Docker Compose

Docker Compose 是一个可用于定义和运行多容器 Docker 应用程序的工具。使用 Compose,你可以使用 Compose 文件来配置应用程序的服务。然后,使用单个命令,你可以从配置中创建和启动所有服务。

下列任何方式都可以安装 Docker Compose 。

方式 1、使用二进制文件安装 Docker Compose

这里 下载最新 Docker Compose 。

当我在写这篇文章时,最新版本是 2.6.1

运行下列命令安装最新稳定的 Docker Compose 文件:

$ sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

如果有更新版本,只需要将上述命令中的 v2.6.1 替换为最新的版本号即可。请不要忘记数字前的 "v"

最后,使用下列命令赋予二进制文件可执行权限:

$ sudo chmod +x /usr/local/bin/docker-compose

运行下列命令检查安装的 Docker Compose 版本:

$ docker-compose version
Docker Compose version v2.6.1

方式 2、使用 Pip 安装 Docker Compose

或许,我们可以使用 Pip 安装 Docker Compose 。Pip 是 Python 包管理器,用来安装使用 Python 编写的应用程序。

参考下列链接安装 Pip 。

安装 Pip 后,运行以下命令安装 Docker Compose。下列命令对于所有 Linux 发行版都是相同的!

$ pip install docker-compose

安装 Docker Compose 后,使用下列命令检查版本:

$ docker-compose --version

你将会看到类似下方的输出:

docker-compose version 2.6.1, build 8a1c60f6

恭喜你!我们已经成功安装了 Docker 社区版和 Docker Compose 。

安装了 Docker,然后呢?查看本系列的下一篇文章,了解 Docker 基础知识。

要在基于 RPM 的系统(例如 RHEL、Fedora、CentOS、AlmaLinux、Rocky Linux 和 openSUSE)中安装 Docker,请参考以下链接。

总结

在这篇教程中,我们讨论了 Docker 是什么,如何在 Ubuntu 22.04 LTS Jammy Jellyfish 中安装 Docker 。然后学习了如何通过运行 hello-world Docker 镜像测试 Docker 是否成功安装。最后,我们通过使用两种不同的方式安装 Docker Compose 作为本教程的结尾。

资料


via: https://ostechnix.com/install-docker-ubuntu/

作者:sk 选题:lkxed 译者:Donkey 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

面向初学者的 Docker 基本命令指南。

这篇详细的 Docker 教程覆盖了核心的 Docker 命令,比如,如何创建新容器、运行容器、删除容器等。另外,这篇教程也解释了如何从已有的容器构建你自己的 Docker 镜像,如何移除容器和镜像。言归正传,现在开始 Docker 的基本用法。

Docker 安装步骤

大多数现代 Linux 操作系统都可以安装 Docker。如果还没安装过 Docker,请参考下面的步骤:

什么是 Docker 镜像和 Docker 容器?

在开始 Docker 之前,我先说明一下 Docker 镜像和 Docker 容器是什么。

Docker 镜像是一个描述容器如何运行的的文件,Docker 容器是 Docker 镜像在运行或被终止时的一个阶段。

容器和主机上的其他文件是隔离的。

当我们运行一个 Docker 容器的时候,它会使用一个被隔离出来的文件系统,这个文件系统是由一个 Docker 镜像提供的。Docker 镜像包含了运行应用程序所需要的一切东西 - 所有的依赖、配置、脚本、二进制文件等等。

镜像也包含容器所需要的其他配置项,比如说环境变量、默认运行的命令,以及其他元数据。

Linux 下的 Docker 入门

下面的所有步骤都已在 Ubuntu 22.04、20.04 以及 18.04 LTS 服务器版本中测试通过。后续小节中提供的步骤对于所有 Linux 平台都是通用的。比如,在基于 RHEL 的系统中(比如 AlmaLinux)可以运行相同的命令。

1、搜索 Docker 镜像

我们可以从叫做 Docker hub 的 Docker 官方库获得镜像,或者我们也可以制作自己的镜像。

有些人可能不清楚,Docker hub 是一个线上的中心化仓库,Docker 用户们在上面构建、测试、然后保存他们的 Docker 镜像。Docker hub 有数以万计的 Docker 镜像,而且这个数字还在每天增长。

你可以从命令行通过 `docker search 命令搜索任意 Docker 镜像。

比如要搜索基于 Alpine Linux 的 Docker 镜像,运行:

$ sudo docker search alpine

输出结果:

Search Docker Images

搜索基于 Ubuntu 的镜像,运行:

$ sudo docker search ubuntu

你还可以搜索其他任意的应用,比如 Nginx,像下面这样:

$ sudo docker search nginx

Docker hub 有各种各样的镜像。你能在 Docker hub 上找到各种已构建好的 Docker 镜像,比如说操作系统、应用,或者多个应用的合体(比如 LAMP 栈)。

如果你找的东西不在上面,你还可以构建一个镜像,然后通过 Docker hub 向其他人开放,或者只是自己用。

2、下载 Docker 镜像

从终端运行下面的命令可以下载 Ubuntu OS 的 Docker 镜像:

$ sudo docker pull ubuntu

上面的这个命令会从 Docker hub 下载最新的 Ubuntu 镜像。

输出结果:

Using default tag: latest
latest: Pulling from library/ubuntu
405f018f9d1d: Pull complete
Digest: sha256:b6b83d3c331794420340093eb706a6f152d9c1fa51b262d9bf34594887c2c7ac
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest

你也可以用下面的命令下载指定版本的 Ubuntu 镜像:

$ sudo docker pull ubuntu:20.04

Docker 允许我们下载任何镜像,并且在那个镜像上创建容器,这些操作与主机的操作系统无关。

比如要下载 Alpine 系统的镜像,运行:

$ sudo docker pull alpine

Download Docker Images

3、列出 Docker 镜像

所有已下载的 Docker 镜像都保存在 /var/lib/docker 路径下。

要查看所有已下载的 Docker 镜像,运行:

$ sudo docker images

输出结果:

REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
ubuntu       latest    27941809078c   3 weeks ago   77.8MB
ubuntu       20.04     20fffa419e3a   3 weeks ago   72.8MB
alpine       latest    e66264b98777   5 weeks ago   5.52MB

List Docker Images

从上面可以看出来,我已经下载了三个 Docker 镜像 - Ubuntu latest、Ubuntu 20.04 和 Alpine Linux。

现在,我们看一下接下来如何从下载的镜像启动或者运行容器。

4、运行 Docker 容器

有两种方法我们可以启动一个容器 - 使用 Docker 镜像的 标签 TAG 或者 镜像 ID Image ID

标签指的是一个特定的镜像快照, 镜像 ID Image ID 是那个镜像对应的唯一识别码。

可以查看下面这个截图:

Docker Image Tag and ID

从上面的解脱可以看到,标签是 latest20.04

  • 27941809078c 是 Ubuntu latest 的 Docker 镜像的镜像 ID,
  • 20fffa419e3a 是 Ubuntu 20.04 的 Docker 镜像的镜像 ID,
  • e66264b98777 是 Alpine latest 的 Docker 镜像的镜像 ID。
4.1、使用标签运行容器

下载选择好的 Docker 镜像后,运行下面的命令来启动 Docker 容器,并且通过它的标签进行连接。

$ sudo docker run -t -i ubuntu:latest /bin/bash

或者,

$ sudo docker run -it ubuntu:latest /bin/bash

这里,

  • -t:在 Ubuntu 容器内分配一个伪终端。
  • -i:通过从容器获取一个标准输入(STDIN),允许我们创建一个可交互的连接。
  • ubuntu:latest:标签为 latest 的 Ubuntu Docker 镜像。
  • /bin/bash:新容器的 BASH shell。这个是可选项。如果你不加 shell 的话,会分配默认的 shell 给容器。

启动容器后,会自动进入容器的 shell(命令行):

Run Containers Using Tag

基于最新 Ubuntu 镜像的容器现在已经启动了。所有的新容器都会被赋予一个名字和唯一的 ID。从上面的输出可以看到,那个 Ubuntu 容器的 ID 是 2f2a5b826762。一会儿我们会看到从哪找到容器的名字。

现在就可以在容器里面工作了。当你完成容器内的工作后,你可以回到主机操作系统的终端(在我这个例子中,操作系统是 Ubuntu 22.04 LTS)而不需要关掉容器(客户机)。

4.2、从运行中的容器中脱离

使用 CTRL+P 然后 CTRL+Q 就可以从运行中的容器脱离(不需要关闭)。

现在,你就回到了你原来的主机的终端窗口。请注意,容器还在后台运行中,我们并没有关掉它。

4.3、使用镜像 ID 运行容器

另一种启动容器并且连接进去的方式是通过使用镜像 ID,像下面这样:

$ sudo docker run -it 20fffa419e3a /bin/bash

这里,

  • 20fffa419e3a - 镜像 ID

CTRL+P 然后 CTRL+Q 可以从当前容器中脱离回到主机系统的终端。我们只是从容器中脱离,但是没有让它停止。容器仍然在后台运行中。

4.4. 在脱离模式中运行容器

在前面的小结中,我们启动了一个容器并且立刻连接了进去。然后当容器中的工作结束后,我们从容器中脱离了出来。

你也可以在脱离模式(不需要自动连接进去)中启动容器。

在后台运行一个容器,输入命令:

$ sudo docker run -it -d alpine:latest

输出结果:

d74f2ceb5f3ad2dbddb0b26e372adb14efff91e75e7763418dbd12d1d227129d

上面输出结果的前 12 字符代表的是容器的 ID。

通过 docker ps 命令,你可以验证容器是否在运行:

$ sudo docker ps
CONTAINER ID   IMAGE           COMMAND     CREATED         STATUS         PORTS     NAMES
d74f2ceb5f3a   alpine:latest   "/bin/sh"   3 seconds ago   Up 2 seconds             zen_pascal

Run Containers In Background

从上面个的输出结果中可以看到,我们创建了一个 Alpine 容器,但是还没有连接进去。

如果你想连接进去,很简单,运行:

$ sudo docker attach d74f2ceb5f3a

5、查看运行中的容器

查看运行中的容器,运行下面的命令:

$ sudo docker ps

输出结果:

CONTAINER ID   IMAGE           COMMAND       CREATED          STATUS          PORTS     NAMES
f7e04eed577e   20fffa419e3a    "/bin/bash"   6 minutes ago    Up 6 minutes              brave_mclean
2f2a5b826762   ubuntu:latest   "/bin/bash"   18 minutes ago   Up 18 minutes             hungry_leavitt

View Running Containers

这里,

  • f7e04eed577e 是由镜像 2f2a5b826762 创建的 Ubuntu 容器的 ID。并且,brave_mclean 是这个容器的名字。
  • 2f2a5b826762 是由镜像 “ubuntu:latest” 创建的 Ubuntu 容器的 ID。并且,hungry_leavitt 是这个容器的名字。

当一个新容器被创建后,会赋给它一个唯一的 ID 和名字,这样我们就能通过它的 ID 和名字来连接它。

注意:请注意容器 ID 和 Docker 镜像 ID 是不同的

列出所有可用的(运行或者停止)容器,运行:

$ sudo docker ps -a

6、从运行中的容器脱离或连接

首先,通过 docker ps 命令找到容器的 ID。

$ sudo docker ps

然后,运行 docker attach 命令连接到运行中的容器。

$ sudo docker attach <container-id>

比如像下面这样,我要连接到 ID 为 f7e04eed577e 的容器:

$ sudo docker attach f7e04eed577e

你也可以通过使用它的名字连接到一个容器。

$ sudo docker attach brave_mclean

现在你就登录到这个容器了。

想要从容器脱离,只要按 CTRL+P 然后 CTRL+Q

7、启动、重启、暂停和终止容器

你可以使用容器的名字或 ID 来启动,重启,暂停或者终止一个 Docker 容器。

首先,通过 docker ps -a 命令找到容器的名字或 ID。

Find Container ID And Name

现在,通过使用 docker start 命令,加上名字或 ID,你可以启动一个容器,像下面这样:

$ sudo docker start modest_cray
$ sudo docker start 10615254bb45

用空格隔开,就可以启动多个容器,像下面这样:

$ sudo docker start 24b5ee8c3d3a 56faac6d20ad d74f2ceb5f3a

优雅的重启一个运行中的容器,运行:

$ sudo docker start 10615254bb45

暂停一个运行中的容器:

$ sudo docker pause 10615254bb45

把暂停的容器恢复过来:

$ sudo docker unpause 10615254bb45

直到其它容器都停止前,阻塞一个容器:

$ sudo docker wait 10615254bb45

我们可以很容易地通过使用它的名字或 ID 来终止一个容器。如果你已经在容器的 shell 里了,只需要运行下面的命令就可以非常简单的终止:

# exit

你也可以使用下面的命令从 Docker 的主机系统中终止(关闭容器)容器:

$ sudo docker stop 10615254bb45

用空格隔开,你可以退出多个容器,像下面这样。

$ sudo docker stop 35b5ee8c3d3a 10615254bb45

在退出容器之后,通过列出所有容器的命令来确保它确实被终止了:

$ sudo docker ps

8、强行关闭 Docker 容器

docker stop 命令可以非常优雅的关掉运行中的容器。有时候,你可能卡在一个没有响应的容器,或者你想强制关掉容器。

通过给一个运行中的容器发送 SIGKILL 来强行关闭容器,运行:

$ sudo docker kill 10615254bb45

9、在关闭容器后自动删除他们

也许你想测试一个容器,然后当你完成在容器中的工作就把它删掉。如果是这样,通过使用 --rm 标签在关闭后自动删掉容器:

$ sudo docker run -it --rm debian:latest

当你从容器中退出,它会自动被删掉。

Automatically Delete Containers

从上面的结果可以看到,我先创建了一个新的 Debian 容器。当我退出这个容器的时候,它就被自动删掉了。docker ps -a 命令的输出结果显示,Debian 容器现在不存在。

10、给容器命名

如果你再看一下之前命令的输出结果,当你启动一个容器的时候,每个容器都被赋予了一个随机的名字。如果你不命名你的容器,Docker 会自动替你给他们命名。

现在看一下下面的例子:

$ sudo docker run -it -d alpine:latest
2af79e97a825c91bf374b4862b9e7c22fc22acd1598005e8bea3439805ec335d
$ sudo docker run -it -d alpine:latest
80b53b7e661d33696b65c78267fc3f067b6100799c925910db4721963e3fae0a
$ sudo docker ps
CONTAINER ID   IMAGE           COMMAND     CREATED         STATUS         PORTS     NAMES
80b53b7e661d   alpine:latest   "/bin/sh"   3 seconds ago   Up 2 seconds             bold_margulis
2af79e97a825   alpine:latest   "/bin/sh"   6 seconds ago   Up 5 seconds             recursing_taussig

从上面的结果可以看到,尽管我用同一个 Docker 镜像创建了两个容器,它们获得了不同的 ID 和名字。

如果你想给容器赋一个不变的名字,使用 --name 标签,像下面这样:

$ sudo docker run -it -d --name ostechnix_alpine alpine:latest

上面的命令会在脱离模式中创建一个叫做 ostechnix_alpine 的新容器。

我们看一下当前运行的容器列表:

$ sudo docker ps

输出结果:

CONTAINER ID   IMAGE           COMMAND     CREATED         STATUS         PORTS     NAMES
397111fac537   alpine:latest   "/bin/sh"   2 seconds ago   Up 2 seconds             ostechnix_alpine
80b53b7e661d   alpine:latest   "/bin/sh"   7 minutes ago   Up 7 minutes             bold_margulis
2af79e97a825   alpine:latest   "/bin/sh"   7 minutes ago   Up 7 minutes             recursing_taussig

Assign Name To Containers

注意到上面输出结果中的第一个容器的名字了吗?对了,我们给这个容器分配了一个自定义的名字(也就是 ostechnix_alpine)。

给容器分配自定义的名字可以给我们带来其他好处。只要看一下容器的名字,我们就能很容易的确定那个容器里面安装了什么。

11、构建自定义 Docker 镜像

Docker 不仅仅是下载和使用已存在的容器。你也可以创建自己的自定义 Docker 镜像。

现在我们开始一个 Ubuntu 容器:

$ sudo docker run -it ubuntu:latest

现在,你会进入到容器的 shell。

然后,在容器中,你可以安装任何的软件或者做你想做的事情。

比如,我们在容器中安装 Apache Web 服务器。

# apt update
# apt install apache2

相似地,在容器中,可以根据自己的需要安装和测试软件。

完成以后,从容器脱离(不要退出)回到主机系统的 shell。不要终止或者关闭容器。使用 CTRL+P 然后 CTRL+Q 从容器中脱离,这样不会关闭容器。

在你的 Docker 主机的终端,运行下面的命令来找到容器 ID:

$ sudo docker ps

最后,创建一个当前运行中的容器的 Docker 镜像,使用命令:

$ sudo docker commit 377e6d77ebb5 ostechnix/ubuntu_apache

输出结果:

sha256:bc5e5f95ca592a3585fda2c5a40ec30c98e292046ef70390a2c3b7863cc6f7c1

这里,

  • 377e6d77ebb5 – Ubuntu 容器的 ID。
  • ostechnix – 创建容器的用户的名字。
  • ubuntu_apache – 用户 ostechnix 创建的 Docker 镜像的名字。

现在我们查看一下新的 Docker 镜像是否被创建了,使用下面的命令:

$ sudo docker images

输出结果:

ostechnix/ubuntu_apache

Build Custom Docker Images

从上面给的结果中可以看到,从运行中的容器创建的新 Docker 镜像已经在我们的 Docker 主机系统中了。

现在你就可以从这个新的 Docker 镜像创建行容器了,用之前的命令:

$ sudo docker run -it ostechnix/ubuntu_apache

12、移除容器

当你在 Docker 容器中完成所有开发后,如果你不需要它们了,你可以删掉它们。

为此,首先我们需要终止(关闭)运行中的容器。

用这个命令来看一下运行中的容器:

$ sudo docker ps

输出结果:

CONTAINER ID   IMAGE           COMMAND   CREATED         STATUS         PORTS     NAMES
377e6d77ebb5   ubuntu:latest   "bash"    7 minutes ago   Up 7 minutes             elegant_beaver

通过使用它的 ID 来终止运行中的容器:

$ sudo docker stop 377e6d77ebb5

现在,使用这个命令删除容器:

$ sudo docker rm 377e6d77ebb5

同样,如果不再需要所有的容器,关闭并删除它们。

一个一个的删除多个容器会是一项繁琐的工作。所以,我们可以把所有停止的容器一次性删掉,运行:

$ sudo docker container prune

Y 然后回车键,这些容器就被删掉了。

WARNING! This will remove all stopped containers.
Are you sure you want to continue? [y/N] y
Deleted Containers:
397111fac5374921b974721ee646b2d5fbae61ca9c6e8b90fbf47952f382a46b
80b53b7e661d33696b65c78267fc3f067b6100799c925910db4721963e3fae0a
[...]
Total reclaimed space: 176B

Delete Containers

这个命令只有在最新版中有效。

使用下面的命令来验证是否所有容器都被删除了:

$ sudo docker ps -a

如果看不到任何结果,说明所有容器被删掉了。

13、删除 Docker 镜像

记住,在删除所有镜像之前,首先要删掉所有从那些镜像创建的容器。

当你删掉容器后,你可以删掉你不需要的 Docker 镜像。

列出所有下载的 Docker 镜像:

$ sudo docker images

输出结果:

REPOSITORY                TAG       IMAGE ID       CREATED          SIZE
ostechnix/ubuntu_apache   latest    bc5e5f95ca59   14 minutes ago   229MB
debian                    latest    d2780094a226   11 days ago      124MB
ubuntu                    latest    27941809078c   3 weeks ago      77.8MB
ubuntu                    20.04     20fffa419e3a   3 weeks ago      72.8MB
alpine                    latest    e66264b98777   5 weeks ago      5.52MB

从上面可以看到,在我们的主机上有 5 个 Docker 镜像。

通过使用镜像 ID 来删掉它们:

$ sudo docker rmi ce5aa74a48f1

输出结果:

Untagged: ostechnix/ubuntu_apache:latest
Deleted: sha256:bc5e5f95ca592a3585fda2c5a40ec30c98e292046ef70390a2c3b7863cc6f7c1
Deleted: sha256:a8e4797160a2b2d33d8bd1bd67e008260c022b3a53fbcc198b2b74d9eae5961d

同样,删除其他所有 Docker 镜像。

删掉所有未运行的容器、所有镜像、构建的缓存、所有网络,运行:

$ sudo docker system prune -a

使用这个命令的时候要注意,它会删掉所有没有使用的容器、网络、镜像(包括 挂起 dangling 未使用 unreferenced 的)

Delete Everything In Docker

默认情况下,即使当前没有容器在使用 磁盘卷 volumes ,为防止重要数据被删除,磁盘卷也不会被删除。

如果你想删掉所有东西,包括分配的卷,使用 --volumes 标签。

$ sudo docker system prune -a --volumes

Docker 问题汇总

如果 Docker 镜像正在被运行或停止的容器使用,Docker 不会允许你删除这些镜像。

比如,当我尝试从一个以前的 Ubuntu 服务器上删除 ID 为 b72889fa879c 的 Docker 镜像。我会得到下面的错误:

Error response from daemon: conflict: unable to delete b72889fa879c (must be forced) - image is being used by stopped container dde4dd285377

这是因为你想删除的 Docker 镜像正在被另一个容器使用。

所以,我们先查看一下运行中的容器,使用命令:

$ sudo docker ps

输出结果:

Show running docker containers

噢,没有运行中的容器。

我们在看一下所有的容器(运行和停止的),用这个命令:

$ sudo docker ps -a

输出结果:

Show running and stopped docker containers

可以看到,仍然有停止的容器在使用其中一个 Docker 镜像。所以,我们先把所有容器删掉。

比如:

$ sudo docker rm 12e892156219

类似地,向上面那样,用对应容器的 ID 将它们都删除。

当把所有容器删掉后,移除掉 Docker 镜像。

比如:

$ sudo docker rmi b72889fa879c

就这么简单。现在确认是否还有其他 Docker 镜像在主机上,使用命令:

$ sudo docker images

你现在应该不再有任何 docker 镜像了。

总结

在这篇全面的 Docker 入门教程中,我们解释了 Docker 的基本操作,比如创建、运行、搜索、删除容器,还有从 Docker 镜像构建你自己的容器。同时,我们也解释了如何在不需要 Docker 容器和镜像的时候删除它们。

希望你现在对 Docker 的使用 有一个基本的了解。

更多细节,请参考这篇教程最下面的官方资源链接,或者在下面的评论区进行评论。

相关资料


via: https://ostechnix.com/getting-started-with-docker/

作者:sk 选题:lkxed 译者:MCGA 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

大家好!我又写了一篇关于 我最喜欢的电脑工具 的文章。这一篇讲的是 Docker Compose!

本文主要就是讲一讲我对 Docker Compose 有多么满意啦(不讨论它的缺点)!咳咳,因为它总能够完成它该做的,并且似乎总能有效,更棒的是,它的使用还非常简单。另外,在本文中,我只讨论我是如何用 Docker Compose 来搭建开发环境的,而不涉及它在生产中的使用。

最近,我考虑了很多关于这种个人开发环境的搭建方式,原因是,我现在把所有的计算工作都搬到了一个私有云上,大概 20 美元/月的样子。这样一来,我就不用在工作的时候花时间去思考应该如何管理几千台 AWS 服务器了。

在此之前,我曾花了两天的时间,尝试使用其他的工具来尝试搭建一个开发环境,搭到后面,我实在是心累了。相比起来,Docker Compose 就简单易用多了,我非常满意。于是,我和妹妹分享了我的 docker-compose 使用经历,她略显惊讶:“是吧!你也觉得 Docker Compose 真棒对吧!” 嗯,我觉得我应该写一篇博文把过程记录下来,于是就有了你们看到的这篇文章。

我们的目标是:搭建一个开发环境

目前,我正在编写一个 Ruby on Rails 服务(它是一个计算机“调试”游戏的后端)。在我的生产服务器上,我安装了:

  • 一个 Nginx 服务器
  • 一个 Rails 服务
  • 一个 Go 服务(使用了 gotty 来代理一些 SSH 连接)
  • 一个 Postgres 数据库

在本地搭建 Rails 服务非常简单,用不着容器(我只需要安装 Postgres 和 Ruby 就行了,小菜一碟)。但是,我还想要把匹配 /proxy/* 的请求的发送到 Go 服务,其他所有请求都发送到 Rails 服务,所以需要借助 Nginx。问题来了,在笔记本电脑上安装 Nginx 对我来说太麻烦了。

是时候使用 docker-compose 了!

docker-compose 允许你运行一组 Docker 容器

基本上,Docker Compose 的作用就是允许你运行一组可以互相通信 Docker 容器。

你可以在一个叫做 docker-compose.yml 的文件中,配置你所有的容器。我在下方将贴上我为这个服务编写的 docker-compose.yml 文件(完整内容),因为我觉得它真的很简洁、直接!

version: "3.3"
services:
  db:
    image: postgres
    volumes:
      - ./tmp/db:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: password # yes I set the password to 'password'
  go_server:
    # todo: use a smaller image at some point, we don't need all of ubuntu to run a static go binary
    image: ubuntu
    command: /app/go_proxy/server
    volumes:
      - .:/app
  rails_server:
    build: docker/rails
    command: bash -c "rm -f tmp/pids/server.pid && source secrets.sh && bundle exec rails s -p 3000 -b '0.0.0.0'"
    volumes:
      - .:/app
  web:
    build: docker/nginx
    ports:
      - "8777:80" # this exposes port 8777 on my laptop

这个配置包含了两种容器。对于前面两个容器,我直接使用了现有的镜像(image: postgresimage: ubuntu)。对于后面两个容器,我不得不构建一个自定义容器镜像,其中, build: docker/rails 的作用就是告诉 Docker Compose,它应该使用 docker/rails/Dockerfile 来构建一个自定义容器。

我需要允许我的 Rails 服务访问一些 API 密钥和其他东西,因此,我使用了 source secrets.sh,它的作用就是在环境变量中预设一组密钥。

如何启动所有服务:先 “build” 后 “up”

我一直都是先运行 docker-compose build 来构建容器,然后再运行 docker-compose up 把所有服务启动起来。

你可以在 yaml 文件中设置 depends_on,从而进行更多启动容器的控制。不过,对于我的这些服务而言,启动顺序并不重要,所以我没有设置它。

网络互通也非常简单

容器之间的互通也是一件很重要的事情。Docker Compose 让这件事变得超级简单!假设我有一个 Rails 服务正在名为 rails_server 的容器中运行,端口是 3000,那么我就可以通过 http://rails_server:3000 来访问该服务。就是这么简单!

以下代码片段截取自我的 Nginx 配置文件,它是根据我的使用需求配置的(我删除了许多 proxy_set_headers 行,让它看起来更清楚):

location ~ /proxy.* {
  proxy_pass http://go_server:8080;
}
location @app {
  proxy_pass http://rails_server:3000;
}

或者,你可以参考如下代码片段,它截取自我的 Rails 项目的数据库配置,我在其中使用了数据库容器的名称(db):

development:
  <<: *default
  database: myproject_development
  host: db # <-------- 它会被“神奇地”解析为数据库容器的 IP 地址
  username: postgres
  password: password

至于 rails_server 究竟是如何被解析成一个 IP 地址的,我还真有点儿好奇。貌似是 Docker 在我的计算机上运行了一个 DNS 服务来解析这些名字。下面是一些 DNS 查询记录,我们可以看到,每个容器都有它自己的 IP 地址:

$ dig +short @127.0.0.11 rails_server
172.18.0.2
$ dig +short @127.0.0.11 db
172.18.0.3
$ dig +short @127.0.0.11 web
172.18.0.4
$ dig +short @127.0.0.11 go_server
172.18.0.5

是谁在运行这个 DNS 服务?

我(稍微)研究了一下这个 DNS 服务是怎么搭建起来的。

以下所有命令都是在容器外执行的,因为我没有在容器里安装很多网络工具。

第一步::使用 ps aux | grep puma,获取 Rails 服务的进程 ID。

找到了,它是 1837916!简单~

第二步::找到和 1837916 运行在同一个网络命名空间的 UDP 服务。

我使用了 nsenter 来在 puma 进程的网络命令空间内运行 netstat(理论上,我猜想你也可以使用 netstat -tupn 来只显示 UDP 服务,但此时,我的手指头只习惯于打出 netstat -tulpn)。

$ sudo nsenter -n -t 1837916 netstat -tulpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.11:32847        0.0.0.0:*               LISTEN      1333/dockerd
tcp        0      0 0.0.0.0:3000            0.0.0.0:*               LISTEN      1837916/puma 4.3.7
udp        0      0 127.0.0.11:59426        0.0.0.0:*                           1333/dockerd

我们可以看到,此时有一个运行在 59426 端口的 UDP 服务,它是由 dockerd 运行的!或许它就是我们要找的 DNS 服务?

第三步:确定它是不是我们要找的 DNS 服务

我们可以使用 dig 工具来向它发送一个 DNS 查询:

$ sudo nsenter -n -t 1837916 dig +short @127.0.0.11 59426 rails_server
172.18.0.2

奇怪,我们之前运行 dig 的时候,DNS 查询怎么没有发送到 59426 端口,而是发送到了 53 端口呢?这到底是怎么回事呀?

第四步:iptables

对于类似“这个服务似乎正运行在 X 端口上,但我却在 Y 端口上访问到了它,这是什么回事呢?”的问题,我的第一念头都是“一定是 iptables 在作怪”。

于是,我在运行了容器的网络命令空间内执行 iptables-save,果不其然,真相大白:

$ sudo nsenter -n -t 1837916 iptables-save
.... redacted a bunch of output ....
-A DOCKER_POSTROUTING -s 127.0.0.11/32 -p udp -m udp --sport 59426 -j SNAT --to-source :53
COMMIT

在输出中有一条 iptables 规则,它将 53 端口的流量发送到了 59426 上。哈哈,真有意思!

数据库文件储存在一个临时目录中

这样做有一个好处:我可以直接挂载 Postgres 容器的数据目录 ./tmp/db,而无需在我的笔记本电脑上管理 Postgres 环境。

我很喜欢这种方式,因为我真的不想在笔记本电脑上独自管理一个 Postgres 环境(我也真的不知道该如何配置 Postgres)。另外,出于习惯,我更喜欢让开发环境的数据库和代码放在同一个目录下。

仅需一行命令,我就可以访问 Rails 控制台

管理 Ruby 的版本总是有点棘手,并且,即使我暂时搞定了它,我也总是有点担心自己会把 Ruby 环境搞坏,然后就要修它个十年(夸张)。

(使用 Docker Compose)搭建好这个开发环境后,如果我需要访问 Rails 控制台 console (一个交互式环境,加载了所有我的 Rails 代码),我只需要运行一行代码即可:

$ docker-compose exec rails_server rails console
Running via Spring preloader in process 597
Loading development environment (Rails 6.0.3.4)
irb(main):001:0>

好耶!

小问题:Rails 控制台的历史记录丢失了

我碰到了一个问题:Rails 控制台的历史记录丢失了,因为我一直在不断地重启它。

不过,我也找到了一个相当简单的解决方案(嘿嘿):我往容器中添加了一个 /root/.irbrc 文件,它能够把 IRB 历史记录文件的保存位置指向一个不受容器重启影响的地方。只需要一行代码就够啦:

IRB.conf[:HISTORY_FILE] = "/app/tmp/irb_history"

我还是不知道它在生产环境的表现如何

到目前为止,这个项目的生产环境搭建进度,还停留在“我制作了一个 DigitalOcean droplet(LCCT 译注:一种 Linux 虚拟机服务),并手工编辑了很多文件”的阶段。

嗯……我相信以后会在生产环境中使用 docker-compose 来运行一下它的。我猜它能够正常工作,因为这个服务很可能最多只有两个用户在使用,并且,如果我愿意,我可以容忍它在部署过程中有 60 秒的不可用时间。不过话又说回来,出错的往往是我想不到的地方。

推特网友提供了一些在生产中使用 docker-compose 的注意事项:

  • docker-compose up 只会重启那些需要重启的容器,这会让重启速度更快。
  • 有一个 Bash 小脚本 wait-for-it,你可以用它来保持等待一个容器,直到另一个容器的服务可用。
  • 你可以准备两份 docker-compose.yaml 文件:用于开发环境的 docker-compose.yaml 和用于生产环境的 docker-compose-prod.yaml。我想我会在分别为 Nginx 指定不同的端口:开发时使用 8999,生产中使用 80
  • 人们似乎一致认为,如果你的项目是一台计算机上运行的小网站,那么 docker-compose 在生产中不会有问题。
  • 有个人建议说,如果愿意在生产环境搭建复杂那么一丢丢,Docker Swarm 就或许会是更好的选择,不过我还没试过(当然,如果要这么说的话,干嘛不用 Kubernetes 呢?Docker Compose 的意义就是它超级简单,而 Kubernetes 肯定不简单 : ))。

Docker 似乎还有一个特性,它能够 把你用 docker-compose 搭建的环境,自动推送到弹性容器服务(ESC)上,听上去好酷的样子,但是我还没有试过。

docker-compose 会有不适用的场景吗

我听说 docker-compose 在以下场景的表现较差:

  • 当你有很多微服务的时候(还是自己搭建比较好)
  • 当你尝试从一个很大的数据库中导入数据时(就像把几百 G 的数据存到每个人的笔记本电脑里一样)
  • 当你在 Mac 电脑上运行 Docker 时。我听说 Docker 在 macOS 上比在 Linux 上要慢很多(我猜想是因为它需要做额外的虚拟化)。我没有 Mac 电脑,所以我还没有碰到这个问题。

以上就是全部内容啦!

在此之前,我曾花了一整天时间,尝试使用 Puppet 来配置 Vagrant 虚拟机,然后在这个虚拟机里配置开发环境。结果,我发现虚拟机启动起来实在是有点慢啊,还有就是,我也不喜欢编写 Puppet 配置(哈哈,没想到吧)。

幸好,我尝试了 Docker Compose,它真好简单,马上就可以开始工作啦!


via: https://jvns.ca/blog/2021/01/04/docker-compose-is-nice/

作者:Julia Evans 选题:lujun9972 译者:lkxed 校对:turbokernel

本文由 LCTT 原创编译,Linux中国 荣誉推出