Docker常用命令

最新推荐文章于 2022-03-26 13:14:18 发布

peter_pes

最新推荐文章于 2022-03-26 13:14:18 发布

阅读量763

点赞数

分类专栏： Docker 文章标签： docker

本文链接：https://blog.csdn.net/peter_pes/article/details/77981634

版权

Docker 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.基本命令

查看版本：

docker version

查看信息：

service info

查看运行状态：

service docker status

设置开机启动：

chkconfig docker on

显示所有镜像：

docker images

显示镜像的所有层(layer)：

docker images --tree

搜索镜像：

docker search ubuntu:14.04

下载镜像：

docker pull ubuntu:14.04

通过本地模板导入镜像：

wget http://download.openvz.org/template/precreated/ubuntu-14.04-x86_64-minimal.tar.gz

cat ubuntu–14.04–x86_64–minimal.tar.gz | docker import – ubuntu:14.04

导出镜像/容器：

docker save -o /root/images/ubuntuI.tar ubuntu:latest（镜像）
docker export -o /root/images/ubuntuC.tar f91e7a72f567（容器）

-o：输出到的文件

载入镜像：

docker load  /root/images/ubuntu.tar
docker import  /root/images/ubuntu.tar ubuntu:v1

导出后再导入(exported-imported)的镜像会丢失所有的历史，而保存后再加载（saveed-loaded）的镜像没有丢失历史和层(layer)。这意味着使用导出后再导入的方式，你将无法回滚到之前的层(layer)，同时，使用保存后再加载的方式持久化整个镜像，就可以做到层回滚（可以执行docker
tag 来回滚之前的层）。用户既可以使用 docker load
来导入镜像存储文件到本地镜像库，也可以使用 docker import
来导入一个容器快照到本地镜像库。这两者的区别在于容器快照文件将丢弃所有的历史记录和元数据信息（即仅保存容器当时的快照状态），而镜像存储文件将保存完整记录，体积也要大。此外，从容器快照文件导入时可以重新指定标签等元数据信息。

运行容器并执行shell：（每运行一次会启动一个容器）

docker run ubuntu:14.04 echo "hello world"
docker run ubuntu:14.04 ifconfig

运行容器：(进入交互模式)

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

-t：表示传递给容器tty终端
-i：是interactive，表示可以交互
–name：指定容器名可以看到我的终端也由[root@localhost ~]变成了root@f91e7a72f567，说明进入了容器的终端，要退出输入exit就可以。
要新开一个终端进入我们之前启动的容器，先查询容器id

查看容器列表：

docker ps –a（所有）
docker ps –l（最后一次创建）

启动容器：

docker start f91e7a72f567

登录容器：（进入交互式）

docker exec -it f91e7a72f567 /bin/bash

运行出一个容器放到后台运行：

docker run -d ubuntu:14.04 /bin/bash -c "while true; do echo hello world; sleep 2; done"

查看日志：

docker logs -ft f91e7a72f567

-f：让 dokcer logs 像使用 tail -f 一样来输出容器内部的标准输出。
-t：给日志加上时间戳

查看容器内的进程：

docker top f91e7a72f567

查看容器详细信息：

docker inspect f91e7a72f567

保存对容器修改：

docker commit -m="some tools installed" -a="peter" f91e7a72f567 ubuntu:latest

-m：提交的描述信息
-a：指定镜像作者 f91e7a72f567：容器ID
ubuntu:latest：指定要创建的目标镜像名

发布镜像：

docker push learn

暂停/恢复容器内所有进程：

docker pause/unpause f91e7a72f567

停止容器：

docker stop f91e7a72f567
docker kill f91e7a72f567

删除容器：

docker rm f91e7a72f567

删除所有容器：

docker rm 'docker ps -a -q'

查看镜像创建历史：

docker history 3241d986e92b

删除镜像：

docker rmi 3241d986e92b

查看指定（ID或者名字）容器的某个确定端口映射到宿主机的端口号：

docker port 3791ea182ff8
docker port sick_borg

设置镜像标签：

docker tag 860c279d2fec runoob/centos:dev
runoob/centos:dev  镜像源名(repository name)：新的标签名(tag)

从服务器获取实时事件：

docker events -f "image"="mysql:5.6" --since="1467302400"

-f ：根据条件过滤事件
–since ：从指定的时间戳后显示所有事件
–until ：流水时间显示到指定的时间为止如果指定的时间是到秒级的，需要将时间转成时间戳。如果时间为日期的话，可以直接使用，如–since=”2016-07-01”

2.运行一个web应用：

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

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

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

-p：绑定指定端口（主机端口：容器内部端口）

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

-p：绑定指定端口和IP（主机端口：容器内部端口）

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

指定绑定 UDP 端口

docker run -p 3306:3306 --name mymysql -v $PWD/data:/mysql_data -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6

-v $PWD/data:/mysql_data：将主机当前目录下的data目录挂载到容器的/mysql_data
-e MYSQL_ROOT_PASSWORD=123456：初始化root用户的密码

3.Dockerfile 构建镜像：

1.创建一个 Dockerfile 文件

runoob@runoob:~$ cat Dockerfile 
# Pull base image
FROM ubuntu:14.04
MAINTAINER peter ""

# update source
RUN echo "deb http://archive.ubuntu.com/ubuntu precise main universe"> /etc/apt/sources.list
RUN apt-get update

# Install curl
RUN apt-get -y install curl

# Install JDK 7
RUN cd /tmp &&  curl -L 'http://download.oracle.com/otn-pub/java/jdk/7u65-b17/jdk-7u65-linux-x64.tar.gz' -H 'Cookie: oraclelicense=accept-securebackup-cookie; gpw_e24=Dockerfile' | tar -xz
RUN mkdir -p /usr/lib/jvm
RUN mv /tmp/jdk1.7.0_65/ /usr/lib/jvm/java-7-oracle/

# Set Oracle JDK 7 as default Java
RUN update-alternatives --install /usr/bin/java java /usr/lib/jvm/java-7-oracle/bin/java 300   
RUN update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/java-7-oracle/bin/javac 300   

ENV JAVA_HOME /usr/lib/jvm/java-7-oracle/

# Install tomcat7
RUN cd /tmp && curl -L 'http://archive.apache.org/dist/tomcat/tomcat-7/v7.0.8/bin/apache-tomcat-7.0.8.tar.gz' | tar -xz
RUN mv /tmp/apache-tomcat-7.0.8/ /opt/tomcat7/

ENV CATALINA_HOME /opt/tomcat7
ENV PATH $PATH:$CATALINA_HOME/bin

ADD tomcat7.sh /etc/init.d/tomcat7
RUN chmod 755 /etc/init.d/tomcat7

# Expose ports.
EXPOSE 8080

# Define default command.
ENTRYPOINT service tomcat7 start && tail -f /opt/tomcat7/logs/catalina.out

第一条FROM，指定使用哪个镜像源 RUN 指令告诉docker 在镜像内执行命令，安装了什么。。。

2.构建

docker build -t runoob/centos:6.7 .

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

4.容器与主机之间的数据拷贝：

1.将主机/www/runoob目录拷贝到容器96f7f14e99ab的/www目录下。

docker cp /www/runoob 96f7f14e99ab:/www/

2.将主机/www/runoob目录拷贝到容器96f7f14e99ab中，目录重命名为www。

docker cp /www/runoob 96f7f14e99ab:/www

3.将容器96f7f14e99ab的/www目录拷贝到主机的/tmp目录中。

docker cp  96f7f14e99ab:/www /tmp/

5.容器间共享数据：

如果你有一些持久性的数据并且想在容器间共享，或者想用在非持久性的容器上，最好的方法是创建一个数据卷容器，然后从此容器上挂载数据。

1.创建数据卷容器

docker create -v /dbdata --name dbstore ubuntu:14.04 /bin/bash

2.使用–volumes-from选项在另一个容器中挂载 /dbdata卷。

不管 test 容器是否运行，其它容器都可以挂载该容器数据卷，当然如果只是单独的数据卷是没必要运行容器的。

docker run –i –t -d --volumes-from dbstore --name db1 ubuntu:14.04 /bin/bash

3.添加另一个容器

docker run –i –t -d --volumes-from dbstore --name db2 ubuntu:14.04 /bin/bash

4.也可以继承其它挂载有 /test 卷的容器

docker run -t -i -d --volumes-from db1 --name db3 ubuntu:14.04 /bin/bash

5.备份数据卷

docker run --privileged=true --rm --volumes-from dbstore -v $(pwd):/backup ubuntu:14.04 tar cvf /backup/backup.tar /dbdata

启动一个新的容器并且从dbstore容器中挂载卷，然后挂载当前目录到容器中为
backup，并备份dbstore卷中所有的数据为backup.tar，执行完成之后删除容器–rm，此时备份就在当前的目录下，名为backup.tar

6.恢复数据卷

docker run -t -i -d -v /backup --name db4 ubuntu:14.04  /bin/bash docker run --privileged=true --rm --volumes-from db4 -v $(pwd):/backup ubuntu:14.04 tar xvf /backup/backup.tar

恢复之前的文件到新建卷中，执行完后自动删除容器 test/ test/b test/d test/c test/a

6.ubuntu容器中安装tomcat：

1.下载ubuntu镜像

docker pull ubuntu:14.04

2.启动容器

docker run -i -t -v /opt/test/:/mnt/software/ ubuntu:14.04 /bin/bash

所有安装程序都放在了宿主机的/opt/test/目录下，现在需要将其挂载到容器的/mnt/software/目录下

3.若退出，运行以下命令进入容器：

docker exec -it b861bcf5862f /bin/bash

进入容器执行以下操作

1. 安装JDK

tar -zxf /mnt/software/jdk-8u131-linux-x64.tar.gz -C .
mv jdk1.8.0_131/ /opt/jdk/

2. 安装tomcat

tar -zxf /mnt/software/apache-tomcat-7.0.72.tar.gz -C .
mv apache-tomcat-7.0.72/ /opt/tomcat/

3. 编写运行脚本

# touch /root/run.sh 
# vi /root/run.sh
#!/bin/bash
export JAVA_HOME=/opt/jdk
export PATH=$JAVA_HOME/bin:$PATH
sh /opt/tomcat/bin/catalina.sh run

chmod u+x /root/run.sh

退出容器

4.创建tomcat镜像

docker commit b861bcf5862f mytomcat:1.0

5.启动tomcat

docker run -d -p 5566:8080 -v /opt/test1/:/opt/tomcat/webapps/ --name mytomcat_1 mytomcat:1.0 /root/run.sh

6.访问tomcat

127.0.0.1:5566

7.搭建本地镜像仓库

仓库端

1. 获取registry镜像

docker pull registry:2.1.1

2. 启动容器

docker run -d -v /opt/registry:/var/lib/registry -p 5000:5000 --restart=always --name registry registry:2.1.1

客户端

3. 修改/etc/docker

Docker目录下新建daemon.json，内容如下：

{ "insecure-registries":["127.0.0.1:5000"] }

4. 重启docker

systemctl daemon-reload
service docker restart

5. 修改镜像tag

docker tag 0a612813fb81 127.0.0.1:5000/kafka:0.11.0.0

6. 把打了tag的镜像上传到私有仓库

docker push 127.0.0.1:5000/kafka:0.11.0.0

其他客户端

7. pull镜像

docker pull 127.0.0.1:5000/kafka:0.110.0.0

8. 查看仓库上的镜像

http://127.0.0.1:5000/v2/_catalog
curl http://127.0.0.1:5000/v2/_catalog

peter_pes

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Docker常用命令

1.基本命令查看版本：docker version查看信息：service info查看运行状态：service docker status设置开机启动：chkconfig docker on显示所有镜像：docker images显示镜像的所有层(layer)：docker images --tree搜索镜像：docker se
复制链接

扫一扫