Docker学习，部署xxljob - CharyGao

架构

镜像:docker镜像,就相当于是一个root文件系统,比如官方镜像像ubuntu就包含了一套完整的ubuntu最小系统的root文件系统
容器:镜像和容器的关系,就像是面向对象程序设计中的类和实例一样,镜像是静态的定义,容器是镜像运行时的实体.容器可以被创建启动停止删除和暂停等
仓库:仓库可以被看一个代码控制中心,用来保存镜像

docker使用客户端服务器架构模式,使用远程api来管理和创建docker容器.docker容器通过docker镜像来创建

概念	说明
docker镜像(images)	docker镜像是用于创建docker容器的模板,比如ubuntu系统
docker容器(container)	容器是独立运行的一个或一组应用,是镜像运行的实体
docker客户端(client)	docker客户端通过命令行或者其他工具使用docker sdk与docker的守护进行通信
docker主机(host)	一个物理或者虚拟的机器用于执行docker守护进程和容器
docker registry	docker仓库用来保存镜像,可以理解为代码控制中的代码仓库,docker hub提供了庞大的镜像集合供使用.一个docekr registry中可以包含多个仓库,每个仓库可以包含多个标签,每个标签对应一个镜像,通常,一个仓库会包含同一个软件不同版本的进行,而标签就常用于对应该软件的各个版本.我们可以通过[仓库名]:[标签]的格式来指定具体是这个软件那个版本的镜像.如果不给出标签,将以latest作为默认标签
docker machine	docker machine是一个简化docekr安装的命令行工具,通过一个简单的命令行即可在对应的平台上安装docker比如virtualbox digital ocean microsoft azure

docker使用

docker helloworld

docker允许你在容器内运行应用程序.在容器内运行一个应用程序并输出helloworld

docker run ubuntu:15.10 /bin/echo "Hello world"

docker:docker的二进制执行文件
run:与前面的docker组合来运行一个容器
ubuntu15.10:指定要运行的镜像,docker首先从本地主机上查找镜像是否存在,如果不存在,docker就会从镜像仓库docker hub下载公共镜像
/bin/echo “hello world”:在启动的容器里面执行的命令

以上命令的含义:docker以一个ubuntu15.10镜像创建一个新容器,然后再容器里面执行 /bin/echo “helloworld”,然后输出结果

交互式容器

通过docker的两个参数-i -t ,让docker运行的容器实现对话能力

docker run -i -t ubuntu:15.10 /bin/bash

-t :在新容器内指定一个伪终端,或者终端
-i :允许你对容器内的标准输入(STDIN)进行交互
cat /proc/version 查看当前系统的版本信息

运行exit命令或者ctrl+d来退出容器

后台启动容器

创建一个以进程方式运行的容器

docker run -d ubuntu:15.10 /bin/sh -c "while true;do echo hello world;sleep 1; done"

这个长字符串叫做容器的id,对每个容器来说都是唯一的,我们可以通过容器的id来查看对应的容器发生了什么.

查看容器有无在运行

docker ps

container id 容器id
image:使用的镜像
command:启动容器时运行的命令
created:容器创建的时间
status:容器状态
1. created(创建中)
2. restarting(重启中)
3. running或者up(运行中)
4. removing(迁移中)
5. paused(暂停中)
6. exited(停止)
7. dead(死亡)
ports:容器端口信息和使用的连接类型(tcp\udp)
names:自动分配的容器名称

原始主机中查看容器内的标准输出

docker logs 52dfdf29ba58

停止容器

docker stop 52dfdf29ba58

docker容器使用

docker客户端

查看docker客户端的所有命令选项

docker

查看具体命令的更深用法,如stats指令的具体用法

docker stats --help

容器获取

来取镜像

docker pull ubuntu

启动容器

使用一个ubuntu镜像启动一个容器,以参数为命令行模式进入该容器

docker run -it ubuntu /bin/bash

-i 交互式操作
-t 终端
ubuntu: ubuntu镜像
/bin/bash:放在镜像名后的是命令,这里我们希望有一个交互式的shell,因此使用的是/bin/bash

查看所有容器的命令

docker ps -a

启动一个已停止的容器

docker start

后台运行

大部分场景下我们是希望docker服务是在后台运行的,我们可以使用-d指定容器的运行模式

docker run -itd --name ubuntu-test ubuntu /bin/bash

-d 默认不会进入该容器,想要进入容器需要使用指令docker exec

停止一个容器

docker stop [容器id]

停止的容器通过docker restart重启

docker restart [容器id]

进入容器

在使用-d参数之后,容器启动后会进入后台,此时想要进入容器,可以通过以下指令进入

docker attach
docker exec : 推荐使用docker exec命令,因为此退出容器终端,不会导致容器的停止

attach命令

docker attach cd2c8040fba6

退出容器,会导致容器停止

exec命令

docekr exec -it cd2c8040fba6 /bin/bash

导出和导入容器

导出本地容器,使用docker export命令

docker export cd2c8040fba6 > ubuntu.tar

导入容器快照

可以使用docker import从容器快照文件中在导入为镜像,以下将快照文件ubuntu.tar导入到镜像ubuntu:v1

cat ./ubuntu.tar | docker import - ubuntu:v1

也可以通过指定url或者某个目录来导入

docker import http://example.com/exampleimage.tgz example/imagerepo

删除容器

删除容器使用docker rm命令

docker rm -f cd2c8040fba6

清理掉所有处于终止状态的容器

docker container prune

web应用

运行一个web应用

将在docker容器中运行一个python flask应用来运行一个web应用

docker pull training/webapp	#载入镜像
docker run -d -P training/webapp python app.py

-d 让容器在后台运行
-P 将容器内部使用的网络端口随机映射到我们使用的主机上

查看web应用容器

docker ps

多了端口信息 ports

0.0.0.0:49153->5000/tcp, :::49153->5000/tcp

docker 开放了5000端口(默认python flask端口)映射到主机端口49153上

我们通过浏览器访问web应用

也可以通过-p参数来设置不一样的端口

docker run -d -p 5000:5000 training/webapp python app.py

容器内部的5000端口映射到我们本地主机的5000端口上

网络端口的快捷方式

通过docker ps命令可以查看到容器的端口映射,docker还提供了另一个快捷方式docker port,使用docker post可以查看指定(id 或者名字)容器的某个确定端口映射到本机的端口号.上面我们创建的容器id为18b8aa6acac6名字为naughty_kalam.我们可以使用

docker port 18b8aa6acac6
docker port naughty_kalam

查看web应用程序日志

查看容器内部的标准输出

docker logs [id或名字]

-f:让docker logs像使用tail -f 一样来输出容器内部的标准输出,从上面可以看出来应用程序使用的是5000端口并且能够看到应用程序的访问日志

查看web应用程序容器的进程

查看容器内部运行的进程

docker top naughty_kalam

检查web应用程序

使用docker inspect 来查看docker的底层信息,它会返回一个json文件记录着docker容器的配置和状态信息

docker inspect naughty_kalam

停止web应用容器

docker stop friendly_perlman

重启web应用

已经停止的web容器,使用docekr start来启动

docker start friendly_perlman

查询最后一次创建的容器

docker ps -l

重启正在运行的容器

docker restart

移除web应用容器

删除不需要的容器

docker rm friendly_perlman

删除容器时,容器必须是停止状态,否则会报错

docker镜像使用

在运行容器时,使用的镜像如果在本地不存在,docker就会自动从docker镜像仓库中下载,默认是从docker hub公共镜像源下载

列出镜像列表

列出本地主机上的镜像

docker images

repository :表示镜像仓库源
tag :镜像的标签
image id :镜像id
created :镜像创建时间
size :镜像大小

同一个仓库源可以有多个tag,代表这个仓库源的不同版本,如ubuntu仓库源里,有15.10 14.04等多个不同的版本,我们使用repository:tag来定义不同的镜像.所以当我们要使用版本为15.10的ubuntu系统镜像阿里运行容器时

docker run -t -i ubuntu:15.10 /bin/bash

-i :交互式操作
-t:终端
ubuntu:15.10 :这里指用ubuntu15.10版本的镜像为基础来启动容器
/bin/bash : 放在镜像名后面的是命令.这里我们希望有个交互式shell,因此用的是/bin/bash

如果要使用ubuntu14.04版本为系统镜像来运行容器时

docker run -i -t ubuntu:14.04 /bin/bash

如果不指定一个镜像的版本标签,例如你只是用ubuntu,docker将默认使用ubuntu:latest镜像

获取一个新的镜像

在本地主机上使用一个不存在的镜像时docker就会自动下载这个镜像.如果我们像预先下载这个镜像,我们就可以使用docker pull命令来下载

docker pull ubuntu:13.10

下完之后就可以直接使用这个镜像来运行docker

查找镜像

我们可以从docker hub网站来搜索镜像,docker hub网站https://hub.docker.com/.我们也可以使用docker search命令搜索镜像.比如我们需要一个httpd的镜像来作为我们的web服务.我们可以通过docker search命令搜索httpd来寻找适合我们的镜像

docker search httpd

name :镜像仓库源的名称
description:镜像的描述
official:是否是docker官方发布
stars:类似github上的star,表示点赞喜欢
automated:自动构建

拖取镜像

docker pull httpd

接着就可以使用这个镜像了

删除镜像

使用docker rmi命令

docker rmi a4c7cb30a6ff

删除所有镜像

docker rim i `docker images -q`

创建镜像

当我们从docker镜像仓库中下载的镜像不能满足我们的需求的时候,我们就可以通过以下两种方式对镜像进行更改

从已创建的容器中更新镜像,并提交这个镜像
使用dockerfile指令来创建一个新的镜像

更新镜像

更新镜像之前我们需要使用镜像来创建一个容器

docker run  -it ubuntu:15.10 /bin/bash

在运行的容器内使用apt-get update命令进行更新,在操作完成之后,输入exit命令来退出容器,此时id为79171d4b8787的容器,是按照我们的需求更改的容器.我们可以通过命令docker commit来提交容器副本

docker commit -m="has update" -a="wanan" 79171d4b8787 ububtu:v2

-m :提交的描述信息
-a :指定镜像作者
79171d4b8787 :容器id
ubuntu:v2 :指定要创建的目标镜像名

我们可以使用docker images来查看我们的新镜像

docker images

使用我们的新镜像ubuntu:v2来启动一个容器

构建镜像

使用命令docker bulid,从零开始来创建一个新的镜像,为此我们需要创建一个Dockerfile文件,其中包含一组指令来告诉docker如何构建我们的镜像

[root@mycentos ~]# cat Dockerfile
FROM    centos:6.7
MAINTAINER      Fisher "fisher@sudops.com"

RUN     /bin/echo 'root:123456' |chpasswd
RUN     useradd runoob
RUN     /bin/echo 'runoob:123456' |chpasswd
RUN     /bin/echo -e "LANG=\"en_US.UTF-8\"" >/etc/default/local
EXPOSE  22
EXPOSE  80
CMD     /usr/sbin/sshd -D

每一个指令都会在镜像上创建一个新的层,每一个指令的前缀必须都是大写的.第一条指令FROM 指定使用那个镜像源,RUN指令告诉docker在镜像内执行命令,安装了什么,然后我们使用Dockerfile文件,通过docker build命令来创建一个镜像

docker build -t wanan/centos:6.7 .

-t :指定要创建的目标镜像名
. : Dockerfile文件所在的目录,可以指定Dockerfile的绝对路径

使用docker images查看创建的镜像已经在列表中存在

我们可以使用新的镜像来创建容器

docker run -it wanan/centos:6.7 /bin/bash

设置镜像标签

我们可以使用docker tag命令,为镜像添加一个新的标签

docker tag 68bb92d72b8d wanan/centos:dev

可以看到id为68bb92d72b8d多一个标签

docker容器连接

前面我们实现了通过网络端口来访问运行在docker容器内的服务.容器中可以运行一些网络应用,要让外部也可以访问这些应用,可以通过-P或者-p参数来指定端口映射,下面通过端口连接到一个docker容器

网络端口映射

创建一个python应用的容器

docker run -d -P training/webapp python app.py

另外,我们可以指定容器绑定的网络地址,比如绑定127.0.0.1.我们使用-P绑定端口号,使用docker ps可以看到容器5000绑定了主机端口49155

我们也可以使用-p标识来指定容器端口绑定到主机端口

-P :是容器内部端口随机映射到主机的端口
-p :是容器内部端口绑定到指定的主机端口

docker run -d -p 5000:5000 training/webapp python app.py

可以指定容器绑定的网络地址,比如绑定127.0.0.1

docker run -d -p 127.0.0.1:5001:5000 training/webapp python app.py

这样我们就可以通过访问127.0.0.5001来访问容器5000端口了.之前的都是默认绑定tcp端口,如果要绑定udp端口,可以在端口后面加上/udp

docker run -d -p 127.0.0.1:5000:5000/udp training/webapp python app.py

docker port 命令可以让我们快捷查看端口的绑定情况

docker port loving_satoshi 5000/udp

docker容器互联

端口映射并不是唯一把docker连接到另一个容器的方法.docker有一个连接系统允许将多个容器连接在一起,共享连接信息.docker连接会创建一个父子关系,其中父容器可以看到子容器的信息

容器命名

当我们创建容器的时候,docker会自动对他进行命名.另外我们也可以使用–name 标识来命名容器

docker run -d -P --name wanan training/webapp python app.py

新建网络

下面创建一个新的docker网络

docker network create -d bridge test-net

-d :参数指定docker网络类型,有bridge overlay

其中overlay网络类型用于swarm mode

连接容器

运行一个容器并连接到新建的test-net网络

docker run -itd --name test1 --network test-net ubuntu /bin/bash

打开一个新的终端,在运行一个容器并加入到test-net网络

docker run -itd --name test2 --network test-net ubuntu /bin/bash

通过平来证明test1容器和test2容器建立了互联关系,如果test1或者test2容器中无ping命令,则在容器内执行一下命令安装ping(可以在一个容器内按装好,提交到容器镜像,在以新的镜像重新运行以上两个容器)

docker exec -it test1 /bin/bash
apt-get update
apt install iputils-ping

这样test1容器就和test2容器建立了相互连接,如果有多个容器需要相互连接,推荐使用docker compose

配置dns

可以在原始主机中的/etc/docker/daemon.json文件中添加以下内容来设置全部容器的dns

{
  "dns" : [
    "114.114.114.114",
    "8.8.8.8"
  ]
}

设置完之后,启动容器的dns会自动配置为114.114.114.114和8.8.8.8.配置完,需要重启docker才能生效.查看容器的dns是否生效可以使用以下命令,他会输出容器的dns信息

docker run -it --rm ubuntu cat etc/resolv.conf

手动指定容器的配置

如果只是想在指定容器设置dns,则可以使用

docker run -it --rm -h host_ubuntu --dns=114.114.114.114 --dns-search=test.com ubuntu

–rm :容器退出时自动起立容器内部的文件系统
-h HOSTNAME 或者 --hostname=HOSTNAME :设定容器的主机名,他会被写入到容器内的/etc/hostname和/etc/hosts
–dns=IP_ADDRESS:添加dns服务器到容器的/etc/resolv.conf中,让容器用这个服务器来解析所有不在/etc/hosts中的主机名
–dns-search=DOMAIN:设定容器的搜索域,当设定搜索域为.example.com时,在搜索一个名为host的主机时,dns不仅搜索host,还会搜索host.example.com

如果在容器启动时没有指定–nds和–dns-search,docker会默认用原始主机上的/etc/resolv.conf来配置dns

docker仓库管理

先给我去https://hub.docker.com免费注册一个账号去

登录和退出

docker login

docker logout

推送镜像

登录之后可以通过docker push命令将自己的镜像推送到docker hub

docker Dockerfile

dockerfile 是一个用来构建镜像的文本文件,文本内容包含了一条条构建镜像所需要的指令和说明

使用dockerfile定制镜像

定制一个nginx镜像

构建好的镜像内会有一个/usr/share/nginx/html/index.html文件

在一个空目录下新建一个名为Dockerfile文件,并在文件内添加以下内容

FROM nginx
RUN echo "这是一个本地创建的nginx镜像" > /usr/share/nginx/html/index.

FROM和RUN指令的作用

FROM:定制的镜像都是基于FROM的镜像,这里的nginx就是定制需要的基础镜像,后续的操作都是基于nginx
RUN: 用于执行后面跟着的命令行命令.有两种格式

shell格式

RUN [命令行命令]
# [命令行命令] 等同于在终端操作的shell命令

exec格式

RUN ["可执行文件","参数1","参数2"]
#例如:
#RUN ["./test.php","dev","offline"]等价于 RUN ./test.php dev offline

注意 dockerfile的指令每一次执行都会在docker上新建一层.所以过多无意义的层会造成镜像膨胀过大

FROM centos
RUN yum -y install wget
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
RUN tar -xvf redis.tar.gz

以上执行会创建3层镜像.可简化为以下格式

FROM centos
RUN yum -y install wget \
&& wget -O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \
&& tar -xvf redis.tar.gz

如上,以&&符号连接命令,这样执行后,只会创建一层镜像

开始构建镜像

在dockerfile文件的存放目录下,执行构建动作.以下实例,通过目录下的dcokerfile构建一个nginx:v3(镜像名称:镜像标签)

最后的.代表本次执行的上下文路径

docker build -t nginx:v3 .

以上显示说明已经构建成功

上下文路径,有提到指令最后一个.是上下文路径,那么什么是上下文路径呢

docker bulid -t nginx:v3 .

上下文路径,是指docker在构建镜像,有时候想要使用到本机的文件(比如复制),docker build 命令得知这个路径之后,会将路径下的所有内容打包.

由于docker的运行模式是c/s.我们本机是c,docker引擎是s.实际的构建过程是在docker引擎下完成的,所以这个时候无法用到我们本机的文件,这就需要我们本机的指定目录下的文件一起打包提供给docker引擎使用.如果未说明最后一个参数,那么默认上下文路径技术dockerfile所在的位置.

上下文路径不要放无用的文件,因为会一起打包发送给docker引擎,如果文件过多会造成过程缓慢.

docker compose

compose简介

compose是用于定义和运行多容器docker应用程序的工具.通过compose,您可以使用yml文件来配置应用程序需要的所有服务,然后使用一个命令就可以从yml文件配置中创建并启动所有服务.

使用compose的三个步骤

使用dockerfile定义应用程序的环境
使用docker-compose.yml定义构成应用程序的服务,这样他们可以在隔离环境中一起运行.
最后,执行docker-compose up命令来启动并运行整个应用程序

docker-compose.yml的配置案例如下

# yaml 配置实例
version: '3'
services:
  web:
    build: .
    ports:
   - "5000:5000"
    volumes:
   - .:/code
    - logvolume01:/var/log
    links:
   - redis
  redis:
    image: redis
volumes:
  logvolume01: {}

compose安装

linux上我们可以从github上下载二进制包来使用

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

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

 docker-compose --version

对于alpine,需要下载依赖包.py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。

新建一个app.py复制进去以下内容

import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)


def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)


@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)

在此实例中,redis是应用程序网络上redis容器的主机名,该主机使用的端口为6379.创建一个requirements.txt

flask
redis

创建dockerfile文件

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["flask", "run"]

FROM python:3.7-alpine:从python3.7映像开始构建镜像
WORKDIR/code:将工作目录设置为/code

  ENV FLASK_APP app.py
  ENV FLASK_RUN_HOST 0.0.0.0

设置flask命令使用的环境变量

RUN apk add --no-cache gcc musl-dev linux-headers:安装gcc ,以便诸如MarkupSafe 和 SQLAlchemy 之类的 Python 包可以编译加速。

  COPY requirements.txt requirements.txt
  RUN pip install -r requirements

复制requirements.txt并安装python依赖项

COPY .:将.项目中的当前目录复制到.镜像中的工作目录
CMD[“flask”,“run”]:容器提供默认的执行命令为:flask run

创建docker-compose.yml

# yaml 配置
version: '3'
services:
  web:
    build: .
    ports:
     - "5000:5000"
  redis:
    image: "redis:alpine"

该compose定义了两个服务:web和redis

web:该web服务使用从dockerfile当前目录中构建的镜像,然后,它将容器和主句绑定到暴露的端口5000.此示例服务使用Flask web服务的默认端口5000
redis:该redis服务使用docker hub的公共redis映像

使用compose命令构建和运行应用

docker-compose up

docker安装ubuntu

查看可用ubuntu

访问 Ubuntu 镜像库地址： https://hub.docker.com/_/ubuntu?tab=tags&page=1。

可以通过 Sort by 查看其他版本的 Ubuntu。默认是最新版本 ubuntu:latest 。

拉取最新的ubuntu镜像

docker pull ubuntu
docker pull ubuntu:latest

查看本地镜像

docker images

运行容器,并可以通过exec命令进入ubuntu容器

docker run -itd --name ubuntu-test ubuntu

安装centos

拉取指定版本的centos镜像

docker pull centos:centos7

查看本地镜像

docker images

运行容器并通过exec命令进入centos容器

docker run -itd --name centos-test centos:centos7
docker exec -it centos-test bash

docker安装nginx

找版本

docker search nginx

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sV9ynXGU-1665117305902)(C:/Users/14980/AppData/Roaming/Typora/typora-user-images/image-20220402230406352.png)]

拉取

docker pull nginx

查看本地镜像

docker images

运行容器

docker run --name nginx-test -p 8080:80 -d nginx

–name nginxe-test :容器名称
-p 8080:80 :端口映射,将本地8080端口映射到容器内部的80端口
-d nginx :设置容器在后台一直执行

docker exec -it nginx-test bash

nginx+php部署

拉取php

docker pull php:5.6-fpm

docker run --name myphp-fpm -v ~/nginx/www:/www -d php:5.6-fpm

–name myphp-fpm:将容器命名为myphp-fpm
-v ~/nginx/www:/www:将主机中项目的目录www挂载到容器的/www

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

mkdir ~/nginx/conf/conf.d

添加 ~/nginx/conf/conf.d/runoob-test-php.conf 文件

server {
    listen       80;
    server_name  localhost;

    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm index.php;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /usr/share/nginx/html;
    }

    location ~ \.php$ {
        fastcgi_pass   php:9000;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  /www/$fastcgi_script_name;
        include        fastcgi_params;
    }
}

配置文件

php:9000:表示php-fpm服务中的url
/www/:是myphp-php中php文件存储路径,映射到本地的~/nginx/www目录

启动nginx

docker run --name runoob-php-nginx -p 8083:80 -d \
    -v ~/nginx/www:/usr/share/nginx/html:ro \
    -v ~/nginx/conf/conf.d:/etc/nginx/conf.d:ro \
    --link myphp-fpm:php \
    nginx

-p 8083:80:端口映射,把nginx中的80映射到本地的8083端口
~/nginx/www:是本地html文件的存储目录,/usr/share/nginx/html是容器内html文件的存储目录
~/nginx/conf/conf.d 是本地nginx配置文件的存储目录,/etc/nginx/conf.d是容器内nginx配置文件的存储目录
–link myphp-fpm:php :是把myphp-fpm的网络并入nginx,并通过修改nginx的/etc/hosts,把域名php映射成127.0.0.1,让nginx通过php:9000访问php-fpm

在~/nginx/www目录下创建index.php

<?php
echo phpinfo();
?>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CYoKKM8X-1665117305903)(C:/Users/14980/AppData/Roaming/Typora/typora-user-images/image-20220403140022917.png)]

docker安装mysql

拉镜像

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ILhjSVpQ-1665117305903)(C:/Users/14980/AppData/Roaming/Typora/typora-user-images/image-20220403140206082.png)]

运行容器

docker run -itd --name mysql -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rzxpy6nV-1665117305904)(C:/Users/14980/AppData/Roaming/Typora/typora-user-images/image-20220403140450894.png)]

-p 3307:3306 :映射容器服务的3306端口到原始主机的3307端口上,外部主机可以通过宿主机ip:3306访问到mysql服务
MYSQL_ROOT_PASSWORD=123456:设置mysql服务root用户的密码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WgTfOAFS-1665117305904)(C:/Users/14980/AppData/Roaming/Typora/typora-user-images/image-20220403141235682.png)]

docker安装tomcat

创建tomact

创建tomcat,用于存放后面相关的东西

mkdir -p ~/tomcat/webapps ~/tomcat/logs ~/tomcat/conf

webapps目录将映射为tomcat容器配置的应用程序目录
logs目录将映射为tomcat容器的日志目录
conf目录里的配置文件经映射为tomcat容器的配置文件

进入tomcat目录,创建Dockerfile文件

FROM openjdk:8-jre

ENV CATALINA_HOME /usr/local/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH
RUN mkdir -p "$CATALINA_HOME"
WORKDIR $CATALINA_HOME

# let "Tomcat Native" live somewhere isolated
ENV TOMCAT_NATIVE_LIBDIR $CATALINA_HOME/native-jni-lib
ENV LD_LIBRARY_PATH ${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$TOMCAT_NATIVE_LIBDIR

# runtime dependencies for Tomcat Native Libraries
# Tomcat Native 1.2+ requires a newer version of OpenSSL than debian:jessie has available
# > checking OpenSSL library version >= 1.0.2...
# > configure: error: Your version of OpenSSL is not compatible with this version of tcnative
# see http://tomcat.10.x6.nabble.com/VOTE-Release-Apache-Tomcat-8-0-32-tp5046007p5046024.html (and following discussion)
# and https://github.com/docker-library/tomcat/pull/31
ENV OPENSSL_VERSION 1.1.0f-3+deb9u2
RUN set -ex; \
    currentVersion="$(dpkg-query --show --showformat '${Version}\n' openssl)"; \
    if dpkg --compare-versions "$currentVersion" '<<' "$OPENSSL_VERSION"; then \
        if ! grep -q stretch /etc/apt/sources.list; then \
# only add stretch if we're not already building from within stretch
            { \
                echo 'deb http://deb.debian.org/debian stretch main'; \
                echo 'deb http://security.debian.org stretch/updates main'; \
                echo 'deb http://deb.debian.org/debian stretch-updates main'; \
            } > /etc/apt/sources.list.d/stretch.list; \
            { \
# add a negative "Pin-Priority" so that we never ever get packages from stretch unless we explicitly request them
                echo 'Package: *'; \
                echo 'Pin: release n=stretch*'; \
                echo 'Pin-Priority: -10'; \
                echo; \
# ... except OpenSSL, which is the reason we're here
                echo 'Package: openssl libssl*'; \
                echo "Pin: version $OPENSSL_VERSION"; \
                echo 'Pin-Priority: 990'; \
            } > /etc/apt/preferences.d/stretch-openssl; \
        fi; \
        apt-get update; \
        apt-get install -y --no-install-recommends openssl="$OPENSSL_VERSION"; \
        rm -rf /var/lib/apt/lists/*; \
    fi

RUN apt-get update && apt-get install -y --no-install-recommends \
        libapr1 \
    && rm -rf /var/lib/apt/lists/*

# see https://www.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/KEYS
# see also "update.sh" (https://github.com/docker-library/tomcat/blob/master/update.sh)
ENV GPG_KEYS 05AB33110949707C93A279E3D3EFE6B686867BA6 07E48665A34DCAFAE522E5E6266191C37C037D42 47309207D818FFD8DCD3F83F1931D684307A10A5 541FBE7D8F78B25E055DDEE13C370389288584E7 61B832AC2F1C5A90F0F9B00A1C506407564C17A3 713DA88BE50911535FE716F5208B0AB1D63011C7 79F7026C690BAA50B92CD8B66A3AD3F4F22C4FED 9BA44C2621385CB966EBA586F72C284D731FABEE A27677289986DB50844682F8ACB77FC2E86E29AC A9C5DF4D22E99998D9875A5110C01C5A2F6059E7 DCFD35E0BF8CA7344752DE8B6FB21E8933C60243 F3A04C595DB5B6A5F1ECA43E3B7BBB100D811BBE F7DA48BB64BCB84ECBA7EE6935CD23C10D498E23

ENV TOMCAT_MAJOR 8
ENV TOMCAT_VERSION 8.5.32
ENV TOMCAT_SHA512 fc010f4643cb9996cad3812594190564d0a30be717f659110211414faf8063c61fad1f18134154084ad3ddfbbbdb352fa6686a28fbb6402d3207d4e0a88fa9ce

ENV TOMCAT_TGZ_URLS \
# https://issues.apache.org/jira/browse/INFRA-8753?focusedCommentId=14735394#comment-14735394
    https://www.apache.org/dyn/closer.cgi?action=download&filename=tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
# if the version is outdated, we might have to pull from the dist/archive :/
    https://www-us.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
    https://www.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
    https://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz

ENV TOMCAT_ASC_URLS \
    https://www.apache.org/dyn/closer.cgi?action=download&filename=tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc \
# not all the mirrors actually carry the .asc files :'(
    https://www-us.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc \
    https://www.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc \
    https://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc

RUN set -eux; \
    \
    savedAptMark="$(apt-mark showmanual)"; \
    apt-get update; \
    \
    apt-get install -y --no-install-recommends gnupg dirmngr; \
    \
    export GNUPGHOME="$(mktemp -d)"; \
    for key in $GPG_KEYS; do \
        gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$key"; \
    done; \
    \
    apt-get install -y --no-install-recommends wget ca-certificates; \
    \
    success=; \
    for url in $TOMCAT_TGZ_URLS; do \
        if wget -O tomcat.tar.gz "$url"; then \
            success=1; \
            break; \
        fi; \
    done; \
    [ -n "$success" ]; \
    \
    echo "$TOMCAT_SHA512 *tomcat.tar.gz" | sha512sum -c -; \
    \
    success=; \
    for url in $TOMCAT_ASC_URLS; do \
        if wget -O tomcat.tar.gz.asc "$url"; then \
            success=1; \
            break; \
        fi; \
    done; \
    [ -n "$success" ]; \
    \
    gpg --batch --verify tomcat.tar.gz.asc tomcat.tar.gz; \
    tar -xvf tomcat.tar.gz --strip-components=1; \
    rm bin/*.bat; \
    rm tomcat.tar.gz*; \
    rm -rf "$GNUPGHOME"; \
    \
    nativeBuildDir="$(mktemp -d)"; \
    tar -xvf bin/tomcat-native.tar.gz -C "$nativeBuildDir" --strip-components=1; \
    apt-get install -y --no-install-recommends \
        dpkg-dev \
        gcc \
        libapr1-dev \
        libssl-dev \
        make \
        "openjdk-${JAVA_VERSION%%[.~bu-]*}-jdk=$JAVA_DEBIAN_VERSION" \
    ; \
    ( \
        export CATALINA_HOME="$PWD"; \
        cd "$nativeBuildDir/native"; \
        gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)"; \
        ./configure \
            --build="$gnuArch" \
            --libdir="$TOMCAT_NATIVE_LIBDIR" \
            --prefix="$CATALINA_HOME" \
            --with-apr="$(which apr-1-config)" \
            --with-java-home="$(docker-java-home)" \
            --with-ssl=yes; \
        make -j "$(nproc)"; \
        make install; \
    ); \
    rm -rf "$nativeBuildDir"; \
    rm bin/tomcat-native.tar.gz; \
    \
# reset apt-mark's "manual" list so that "purge --auto-remove" will remove all build dependencies
    apt-mark auto '.*' > /dev/null; \
    [ -z "$savedAptMark" ] || apt-mark manual $savedAptMark; \
    apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false; \
    rm -rf /var/lib/apt/lists/*; \
    \
# sh removes env vars it doesn't support (ones with periods)
# https://github.com/docker-library/tomcat/issues/77
    find ./bin/ -name '*.sh' -exec sed -ri 's|^#!/bin/sh$|#!/usr/bin/env bash|' '{}' +

# verify Tomcat Native is working properly
RUN set -e \
    && nativeLines="$(catalina.sh configtest 2>&1)" \
    && nativeLines="$(echo "$nativeLines" | grep 'Apache Tomcat Native')" \
    && nativeLines="$(echo "$nativeLines" | sort -u)" \
    && if ! echo "$nativeLines" | grep 'INFO: Loaded APR based Apache Tomcat Native library' >&2; then \
        echo >&2 "$nativeLines"; \
        exit 1; \
    fi

EXPOSE 8080
CMD ["catalina.sh", "run"]

通过Dockerfile文件创建一个镜像,换成自己的名字

docker build -t tomcat .

使用tomcat镜像

docker run --name tomcat -p 8080:8080 -v $PWD/test:/usr/local/tomcat/webapps/test -d tomcat

-p 8080:8080:将主机的8080端口映射到容器的8080端口
-v $PWD/test:/usr/local/tomcat/webapps/test :将主机中当前目录下的test挂载到容器的/test

docker 部署 xxl-job、引用外部配置文件、连接宿主机 Mysql_docker部署xxljob后管理页面进不去-CSDN博客

1. 拉取 xxl- job 源码

git clone https://gitee.com/xuxueli0323/xxl-job.git

2. 使用IDEA打开，打包

3. 复制 jar 包、配置文件、Dockerfile 到 xxl-job 目录下

4. 修改 Dockerfile

FROM openjdk:8-jre-slim
MAINTAINER xuxueli
ENV PARAMS=""
# 设置外部配置文件路径（必须，否则无法加载到此配置文件）
ENV JAVA_OPTS="-Dspring.config.location=/xxl-job/application.properties"
# 复制配置文件到容器中
COPY ./application.properties /xxl-job/application.properties
COPY ./logback.xml /xxl-job/logback.xml
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
ADD xxl-job-admin-*.jar /xxl-job/app.jar
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /xxl-job/app.jar $PARAMS"]

5. 配置连接宿主机数据库

5.1 先找到宿主机IP

主要修改数据库连接信息。宿主机在与容器同一局域网，所以需要先找到宿主机此局域网的 ip。ifconfig 命令找到 docker0 网卡信息，IP为 172.18.0.1

5.2 修改 application.properties 中的数据库连接信息

### web
server.port=8080
server.servlet.context-path=/xxl-job-admin
### actuator
management.server.servlet.context-path=/actuator
management.health.mail.enabled=false
### resources
spring.mvc.servlet.load-on-startup=0
spring.mvc.static-path-pattern=/static/**
spring.resources.static-locations=classpath:/static/
### freemarker
spring.freemarker.templateLoaderPath=classpath:/templates/
spring.freemarker.suffix=.ftl
spring.freemarker.charset=UTF-8
spring.freemarker.request-context-attribute=request
spring.freemarker.settings.number_format=0.##########
### mybatis
mybatis.mapper-locations=classpath:/mybatis-mapper/*Mapper.xml
#mybatis.type-aliases-package=com.xxl.job.admin.core.model
### xxl-job, datasource
spring.datasource.url=jdbc:mysql://172.18.0.1:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
### datasource-pool
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.auto-commit=true
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.pool-name=HikariCP
spring.datasource.hikari.max-lifetime=900000
spring.datasource.hikari.connection-timeout=10000
spring.datasource.hikari.connection-test-query=SELECT 1
spring.datasource.hikari.validation-timeout=1000
### xxl-job, email
spring.mail.host=smtp.qq.com
spring.mail.port=25
spring.mail.username=184248697@qq.com
spring.mail.from=184248697@qq.com
spring.mail.password=roxdezsngxuvbjii
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true
spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
### xxl-job, access token
xxl.job.accessToken=default_token
### xxl-job, i18n (default is zh_CN, and you can choose "zh_CN", "zh_TC" and "en")
xxl.job.i18n=zh_CN
## xxl-job, triggerpool max size
xxl.job.triggerpool.fast.max=200
xxl.job.triggerpool.slow.max=100
### xxl-job, log retention days
xxl.job.logretentiondays=30

6. 构建镜像

docker build -t xxl-job-admin .

7. 运行容器

docker run -d -p 8181:8080 xxl-job-admin

8. 访问

docker结束ps的命令 docker pause stop_mob64ca14079fb3的技术博客_51CTO博客

Docker 容器

容器镜像是轻量的、可执行的独立软件包，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。
容器化软件适用于基于Linux和Windows的应用，在任何环境中都能够始终如一地运行。
容器赋予了软件独立性，使其免受外在环境差异（例如，开发和预演环境的差异）的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。

Docker 容器的基本操作命令(介绍常用的)

docker ps : 列出所有的容器

-a :显示所有的容器，包括未运行的。
-f :根据条件过滤显示的内容。
--format :指定返回值的模板文件。
-l :显示最近创建的容器。
-n :列出最近创建的n个容器。
--no-trunc :不截断输出。
-q :静默模式，只显示容器编号。
-s :显示总的文件大小。

demo:

CONTAINER ID 容器id，IMAGE 镜像名，COMMAND指令，CREATED 创建时间，STATUS（UP代表运行中Exited退出）

PORTS 端口，NAMES 该容器的名称

[root@localhost vagrant]# docker ps -n 5
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                      PORTS               NAMES
33b92f8cce9c        wget:0.1            "/bin/bash"         22 hours ago        Exited (0) 22 hours ago                         upbeat_curie
508ed8c3ff73        wget:0.1            "/bin/bash"         22 hours ago        Exited (137) 22 hours ago                       stupefied_engelbart
1ce8ad1a9184        tomcat              "catalina.sh run"   23 hours ago        Exited (130) 23 hours ago                       objective_shockley
dd081da801ba        4ab4c602aa5e        "/hello"            23 hours ago        Exited (0) 23 hours ago                         practical_kepler
2047648ff8f1        4ab4c602aa5e        "/hello"            2 days ago          Exited (0) 2 days ago                           distracted_booth 

docker run: 创建一个新的容器并运行一个命令

-a stdin: 指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项；
-d: 后台运行容器，并返回容器ID；
-i: 以交互模式运行容器，通常与 -t 同时使用；
-p: 端口映射，格式为：主机(宿主)端口:容器端口
-t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
--name="nginx-lb": 为容器指定一个名称；
--dns 8.8.8.8: 指定容器使用的DNS服务器，默认和宿主一致；
--dns-search example.com: 指定容器DNS搜索域名，默认和宿主一致；
-h "mars": 指定容器的hostname；
-e username="ritchie": 设置环境变量；
--env-file=[]: 从指定文件读入环境变量；
--cpuset="0-2" or --cpuset="0,1,2": 绑定容器到指定CPU运行；
-m :设置容器使用内存最大值
--net="bridge": 指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型；
--link=[]: 添加链接到另一个容器；
--expose=[]: 开放一个端口或一组端口；

demo:

1. 将tomcat 8080映射到宿主机的8080端口

[root@localhost vagrant]# docker run -d --name mytomcat -p 127.0.0.1:8080:8080/tcp tomcat
a19687ed946291bd3687135c1ce8575d864e963f1f8414583dadc3fef43f4ecb
[root@localhost vagrant]# curl -s localhost:8080


<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <title>Apache Tomcat/8.5.37</title>
        <link href="favicon.ico" rel="icon" type="image/x-icon" />
        <link href="favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <link href="tomcat.css" rel="stylesheet" type="text/css" />
    </head>
。。。。
</html>
[root@localhost vagrant]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                      NAMES
a19687ed9462        tomcat              "catalina.sh run"   46 seconds ago      Up 44 seconds       127.0.0.1:8080->8080/tcp   mytomcat 

2.使用-ti进入tomcat服务器

[root@localhost vagrant]# docker run -ti --name mytomcat-it  tomcat /bin/bash
root@d7b9d44753c2:/usr/local/tomcat# ls
BUILDING.txt  CONTRIBUTING.md  LICENSE  NOTICE  README.md  RELEASE-NOTES  RUNNING.txt  bin  conf  include  lib  logs  native-jni-lib  temp  webapps  work 

docker start/stop/restart

docker start 容器id或容器name
docker stop 容器id或容器name
docker restart 容器id或容器name

docker 进入容器之后退出

exit :退出并停止容器
ctrl +p + q: 退出不停止容器

docker kill 强制停止容器

docker kill 容器id或容器name

docker 删除容器

docker rm 容器id
docker rm -f ${docker ps -a -q} 批量删除
docker ps -a -q | xargs docker rm 批量删除（以不定参的形式）

docker logs : 获取容器的日志

-f : 跟踪日志输出
--since :显示某个开始时间的所有日志
-t : 显示时间戳
--tail :仅列出最新N条容器日志

demo:

mytomcat容器的2019-01-01的最新10条以时间戳显示

[root@localhost vagrant]# docker logs --since="2019-01-01" -t --tail=10 mytomcat
2019-01-01T05:19:29.259220695Z 01-Jan-2019 05:19:29.258 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/usr/local/tomcat/webapps/docs] has finished in [42] ms
2019-01-01T05:19:29.259220753Z 01-Jan-2019 05:19:29.258 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deploying web application directory [/usr/local/tomcat/webapps/examples]
2019-01-01T05:19:29.800126765Z 01-Jan-2019 05:19:29.799 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/usr/local/tomcat/webapps/examples] has finished in [541] ms
2019-01-01T05:19:29.800149372Z 01-Jan-2019 05:19:29.799 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deploying web application directory [/usr/local/tomcat/webapps/host-manager]
2019-01-01T05:19:29.868286069Z 01-Jan-2019 05:19:29.854 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/usr/local/tomcat/webapps/host-manager] has finished in [55] ms
2019-01-01T05:19:29.868303404Z 01-Jan-2019 05:19:29.854 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deploying web application directory [/usr/local/tomcat/webapps/manager]
2019-01-01T05:19:29.938959186Z 01-Jan-2019 05:19:29.933 INFO [localhost-startStop-1] org.apache.catalina.startup.HostConfig.deployDirectory Deployment of web application directory [/usr/local/tomcat/webapps/manager] has finished in [79] ms
2019-01-01T05:19:29.942429797Z 01-Jan-2019 05:19:29.940 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]
2019-01-01T05:19:29.985405382Z 01-Jan-2019 05:19:29.979 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["ajp-nio-8009"]
2019-01-01T05:19:29.985417055Z 01-Jan-2019 05:19:29.984 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in 1741 ms 

Docker top ：查看容器中运行的进程信息，支持 ps 命令参数

容器运行时不一定有/bin/bash终端来交互执行top命令，而且容器还不一定有top命令，可以使用docker top来实现查看container中正在运行的进程。

[root@localhost vagrant]# docker top mytomcat
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
root                4471                4456                0                   06:19               ?                   00:00:06            /docker-java-home/jre/bin/java -Djava.util.logging.config.file=/usr/local/tomcat/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djdk.tls.ephemeralDHKeySize=2048 -Djava.protocol.handler.pkgs=org.apache.catalina.webresources -Dorg.apache.catalina.security.SecurityListener.UMASK=0027 -Dignore.endorsed.dirs= -classpath /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar -Dcatalina.base=/usr/local/tomcat -Dcatalina.home=/usr/local/tomcat -Djava.io.tmpdir=/usr/local/tomcat/temp org.apache.catalina.startup.Bootstrap start 

查看所有运行容器的进程信息

docker inspect : 获取容器/镜像的元数据

-f :指定返回值的模板文件。
-s :显示总的文件大小。
--type :为指定类型返回JSON。

这个元信息有点多，我从官网找了几个demo，mytomcat 可以换成容器name或id

1. 获取当前容器的ip

2. 获取该实例的日志

[root@localhost vagrant]# docker inspect --format='{{.LogPath}}' mytomcat
/var/lib/docker/containers/a19687ed946291bd3687135c1ce8575d864e963f1f8414583dadc3fef43f4ecb/a19687ed946291bd3687135c1ce8575d864e963f1f8414583dadc3fef43f4ecb-json.log 

3. 获取当前实例的端口

[root@localhost vagrant]#  docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' mytomcat
 8080/tcp -> 8080

[root@localhost vagrant]# docker port mytomcat
8080/tcp -> 127.0.0.1:8080 

4. 将其格式转换成没有空格的json

docker pause/unpause

docker pause :暂停容器中所有的进程。
docker unpause :恢复容器中所有的进程。

docker cp :用于容器与主机之间的数据拷贝。

demo:

[root@localhost vagrant]# docker cp 32d35ed0c099:/usr/local/tomcat/BUILDING.txt /
[root@localhost vagrant]# cd /
[root@localhost /]# ls
bin  boot  BUILDING.txt  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  vagrant  var 

参考:

Docker概念： http://dockone.io/article/6051

官方docker inspect 详解： https://docs.docker.com/engine/reference/commandline/inspect/#parent-command

# Docker 常用命令

## 镜像管理
### 搜索镜像
- `docker search [镜像名称]`

### 下载镜像
- `docker pull [镜像名称]:[标签]`

### 查看镜像
- `docker images`

### 删除镜像
- `docker rmi [镜像ID]` 或 `docker rmi [镜像名称]:[标签]`

### 导出镜像
- `docker save -o [输出文件名].tar [镜像名称]:[标签]`

### 导入镜像
- `docker load -i [输入文件名].tar`

## 容器管理
### 创建并启动容器
- `docker run -d -p [宿主机端口]:[容器端口] --name [容器名称] [镜像名称]:[标签]`

### 查看正在运行的容器
- `docker ps`

### 查看所有容器（包括停止的）
- `docker ps -a`

### 进入容器
- `docker exec -it [容器ID或名称] /bin/bash`

### 停止容器
- `docker stop [容器ID或名称]`

### 重启容器
- `docker restart [容器ID或名称]`

### 删除容器
- `docker rm [容器ID或名称]`

### 查看容器日志
- `docker logs [容器ID或名称]`

## 容器与宿主机文件交互
### 将宿主机文件复制到容器
- `docker cp [宿主机文件路径] [容器名称]:[容器目标路径]`

### 将容器文件复制到宿主机
- `docker cp [容器名称]:[容器文件路径] [宿主机目标路径]`

## 容器网络管理
### 查看网络
- `docker network ls`

### 创建网络
- `docker network create --subnet=[子网] --gateway=[网关] [网络名称]`

### 连接容器到网络
- `docker network connect [网络名称] [容器ID或名称]`

### 断开容器与网络
- `docker network disconnect [网络名称] [容器ID或名称]`

## Docker Compose 管理
### 启动服务
- `docker-compose up -d`

### 停止服务
- `docker-compose down`

### 查看服务状态
- `docker-compose ps`

### 查看服务日志
- `docker-compose logs`

发表于 2024-04-03 09:12 CharyGao 阅读(1087) 评论(0) 编辑收藏举报