Docker基础学习

〆是凌风呀

已于 2022-03-01 13:34:40 修改

阅读量1.7k

点赞数 1

分类专栏： docker运维文章标签： docker 容器 linux

于 2022-02-02 18:41:04 首次发布

本文链接：https://blog.csdn.net/weixin_43429331/article/details/122771105

版权

docker运维专栏收录该内容

4 篇文章 0 订阅

订阅专栏

学习docker的基础是一件枯燥的事情，但也是一件值得纪念的事情，一步一步从环境的配置、安装、部署，到后面的编排。dock其实真的没有那么难，作为一个没有处理过真业务问题的小白，也只能说这么多。

一、docker环境部署

环境的部署文档以及资料的话百度的很多，但是并不是每篇帖子都能帮助到。还有就是一些官网也有非常多的指导文档可以参考。

1. 清除原有的版本信息

如果环境中之前有部部署过docker环境，可以通过以及的操作来清除之前的环境残留，避免受环境影响产生一些不可预知的问题。

$ sudo yum remove docker  docker-client \                  docker-client-latest \
                  docker-client-latest \
                  docker-engine;

2. 安装一些依赖环境

安装依赖环境的前提是需要提前配置好linux操作系统的镜像源下面提供几个开源镜像站，具体的配置方法在镜像站其实的指导说明，比如阿里云的开源镜像站，他会指导我们这一些小白来如何配置操作系统的软件源。
阿里云镜像源：https://developer.aliyun.com/mirror/
华为云镜像源：https://mirrors.huaweicloud.com/home
另外其实国内的开源镜站还是有好几家的，感兴趣的可以自行收集一下，一般常用也是他们几家

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

3. 添加一个镜像源

官方源： sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

4. 更新缓存

yum mackecache fast

6. 安装docker

yum install -y docker-ce

8. 重启docker

systemctl start docker

10. 查看版本信息

docker  version

12. 配置加速器

如果没配置加速器，依靠我们的第3步中配置的官方镜像源下载的话，可能后期在镜像的拉取的过程中不会那么另人满意，因为官方docker镜像是在海外的节点，可以想像现在的下载速度会有多快啦。当然，加速器的配置各大云厂家也有提供，下边有阿里云加速器的配置过程，如果需要其他厂家的加速器的话可以到百度或者官方的网站上找到，配置方法大同小异。

阿里云容器服务链接：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors
阿里云容器镜像加速器：https://c6nayvsk.mirror.aliyuncs.com
路径：/etc/docker/daemo.json
添加如下配置：
配置信息要注意，字符需要是完全的英文字符
{
“registry-mirrors”: [“https://”]
}

systemctl daemon-reload 
systemctl restart docker

验证加速器

docker info

输入docker info 之后会输入一个屏幕信息，可以看以下的加速器字段，是否为我们配置的加速器地址，如果有以下的显示，或者其他的加速器地址，则证明配置是成功的。

加速器字段：
Registry Mirrors:
https://c6nayvsk.mirror.aliyuncs.com/ 这个字段信息是执行dock info之后的信息

下面针对以上的配置做一个简单的总结可供参考附：简易版安装流程
centos 7 (aliyun)
step 1: 安装必要的一些系统工具

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

Step 2: 添加软件源信息

sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
 Step 3
sudo sed -i 's+download.docker.com+mirrors.aliyun.com/docker-ce+' /etc/yum.repos.d/docker-ce.repo

Step 4: 更新并安装Docker-CE

sudo yum makecache fast
sudo yum -y install docker-ce

Step 4: 开启Docker服务

sudo service docker start

注意：
官方软件源默认启用了最新的软件，您可以通过编辑软件源的方式获取各个版本的软件包。例如官方并没有将测试版本的软件源置为可用，您可以通过以下方式开启。同理可以开启各种测试版本等。

 vim /etc/yum.repos.d/docker-ce.repo
 将[docker-ce-test]下方的enabled=0修改为enabled=1

安装指定版本的Docker-CE:
Step 1: 查找Docker-CE的版本:

 yum list docker-ce.x86_64 --showduplicates | sort -r
   Loading mirror speeds from cached hostfile
   Loaded plugins: branch, fastestmirror, langpacks
   docker-ce.x86_64            17.03.1.ce-1.el7.centos            docker-ce-stable
   docker-ce.x86_64            17.03.1.ce-1.el7.centos            @docker-ce-stable
   docker-ce.x86_64            17.03.0.ce-1.el7.centos            docker-ce-stable
   Available Packages

Step2: 安装指定版本的Docker-CE: (VERSION例如上面的17.03.0.ce.1-1.el7.centos)
sudo yum -y install docker-ce-[VERSION]
安装校验

root@iZbp12adskpuoxodbkqzjfZ:$  docker version
Client:
 Version:      17.03.0-ce
 API version:  1.26
 Go version:   go1.7.5
 Git commit:   3a232c8
 Built:        Tue Feb 28 07:52:04 2017
 OS/Arch:      linux/amd64

Server:
 Version:      17.03.0-ce
 API version:  1.26 (minimum version 1.12)
 Go version:   go1.7.5
 Git commit:   3a232c8
 Built:        Tue Feb 28 07:52:04 2017
 OS/Arch:      linux/amd64
 Experimental: false
Ubuntu (aliyun)

step 1: 安装必要的一些系统工具

sudo apt-get update
sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

step 2: 安装GPG证书

curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -

Step 3: 写入软件源信息

sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
 sudo apt-get -y update
 sudo apt-get -y install docker-ce

安装指定版本的Docker-CE:

Step 1: 查找Docker-CE的版本:
 apt-cache madison docker-ce
docker-ce | 17.03.1~ce-0~ubuntu-xenial | https://mirrors.aliyun.com/docker-ce/linux/ubuntu xenial/stable amd64 Packages
docker-ce | 17.03.0~ce-0~ubuntu-xenial | https://mirrors.aliyun.com/docker-ce/linux/ubuntu xenial/stable amd64 Packages
Step 2: 安装指定版本的Docker-CE: (VERSION例如上面的17.03.1~ce-0~ubuntu-xenial)
sudo apt-get -y install docker-ce=[VERSION]
sudo apt-get -y install docker-ce=[VERSION]
阿里云链接： https://developer.aliyun.com/mirror/docker-ce?spm=a2c6h.13651102.0.0.6cc81b114iDoZd
dockhub链接：https://www.docker.com/community-edition
安装阿里云源：yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
dock-ce安装链接: https://developer.aliyun.com/article/11080

二、docker基本操作以及使用

在完成以了基本的环境部署之后就可以真正的使用到我们的容器啦，可使用到docker自带的一些命令来对容器进行编辑操作。

docker基本操作以及使用
（一）、镜像

列出镜像  docker images   / ocker image ls
查看镜像  docker search [镜像名]
可到hub.docker.com 查到相关的镜像，进入镜像详情页面有下载的方式

下载镜像  dock pull [选项] [Dock Registey 地址【端口号】/] 镜像名[标签] 
docker pull tomcat:版本号  //如果不写的话默认为laster版本
删除镜像 
docker rmi images   [选项] [镜像1][镜像2]  /其中镜像可以是镜像名、镜像长ID、镜像短ID或者镜像摘要
查看镜像ID
docker images -q 
查看镜像的历史变更
docker history [名称]
保存镜像
docker save -o tomcat.tar [镜像名称]
将本地目录下的镜像备份文件导入到本地的docker仓库
方式一（不输出详细信息）
docker load -i tomcat.tar
方式二（输出详细信息）
docker load <tomcat.tar

（二）、容器

查看容器状态

docker ps    //查看运行的容器
docker ps -a  //查看所有的容器（包含运行和退出） 
docker container ls  
docker container

创建容器（镜像名称要放最后，不然要报错：

Error response from daemon: OCI runtime create failed: container_linux.go:380: starting container process caused: exec: "name": executable file not found in $PATH: unknown
Error: failed to start containers: 674ad5dc462d）
dock  run   参数 镜像名称：tag执行的命令
-i  保持和dock容器内的交互，启动容器时，运行的命令结束后容器依然存活，没有退出（如果没有此参数默认退出停止）
-t 为容器的标准输入虚拟一个tty
-d 后台运行容器
--rm 容器启动后执行完蛋命令或程序就销毁  （执行完容器停止命令后就自动销毁）
--name 给容器起一个自定义的名称
-p  定义容器容器（宿主机：内部端口）
docker run --rm -d --name tomcat1 -p 8080:8080 tomcat
docker run -i -t --name tomcat1 tomcat

停止容器运行

docker stop [容器名称/容器ID]
docker stop $(docker ps -a -q)  // 停止所有容器
docker container [容器名称/容器ID]

删除容器

docker rm [镜像名称、镜像id]

查看控制台结果

docker logs [容器id或者容器名]

进入容器

docker exec -i -t [容器ID或者容器名称] bash

主机防火墙

查看已开放的端口
firewall-cmd --list -ports
开启端口
firewall-cmd --zone=public --add-port=8080/tcp --permanent
关闭端口
firewalld-cmd --permanent --zone=public --remo-port=8080/tcp
开启防火墙
systemctl start firewalld
重启防火墙
firewall-cmd --reload   //重启防火墙
firewall systemctl stop firewalld.service  //停止
firewall systemctl disable firewalld.service //禁止firewall开机启动

进入容器内部

docker exec -it (容器ID/容器名称) bash
docker exec -it tomcat bash

文件复制与传输

docker cp [容器名]：/ [容器路径] [宿主机路径]   //从容器复制到宿主机
docker cp [文件名] 容器名：/[容器路径] [宿主机路径]  //从宿主机复制到容器

dock日志

docker logs [参数] [容器名]
-f 查看实时日志
-t 查看日志生产日期
-since 日期
dockerk logs --tail=10 tomcat

docker数据卷

创建数据卷
docker volume create 数据卷名称 
创建数据卷之后默认会放到目录：/var/lib/docker/volume/数据卷名称/_data目录下

查看数据卷
docker volume inspect 数据卷名称
查看全部数据卷信息
docker volume ls 
删除数据卷
docker volume rm 数据卷名称
应用数据卷 
（映射数据卷时，如果数据卷不存在，Docker会自动创建数据卷）
docker run -v  数据卷名称：容器内路径 镜像ID
直接指定一个路径作为数据卷的存储位置 
docker run -v 路径：容器内的路径 镜像ID

安装nginx

nginx目录
/usr/sbin/nginx
/usr/lib/nginx
/etc/nginx      nginx的配置文件
/usr/share/nginx     nginx静态html5文件
nginx容器创建，并创建对应的映射关系
docker run -d -p 80:80 --name nginx-damoe -v /usr/local/nginx/html:/usr/local/nginx/html -v /user/local/nginx/conf/nginx.conf:/etc/nginx/conf.d/deafault.conf -v /usr/local/nginx/logs:/var/log/nginx nginx

查看端口

netstat
netstat -tunlp 用于显示 tcp，udp 的端口和进程等相关情况。

netstat 查看端口占用语法格式：

netstat -tunlp | grep 端口号
-t (tcp) 仅显示tcp相关选项
-u (udp)仅显示udp相关选项
-n 拒绝显示别名，能显示数字的全部转化为数字
-l 仅列出在Listen(监听)的服务状态
-p 显示建立相关链接的程序名

安装数据库
搜索镜像

docker search mysql

下载镜像

docker pull mysql:5.6

创建容器

docker run -d --name  mysql5.6-3306 -p 3306:3306 -e MYSQL_ROOT_PASSWORD="redhat666" mysql:5.6  //密码为redhat666

访问测试（进入容器内部测试）

docker exec -it mysql5.6-3306 bash

登录数据库
mysql -u root -p

授权其他主机登录
mysql>GRANT ALL PRIVILEGES ON *.* TO 'root'@'%'IDENTIFIED BY 'redhat666' WITH GRANT OPTION;

刷新数据库权限

mysql>FLUSH PRIVILEGES;

三、Dockfile使用

dockerfile是用于构建镜像的主要手动，如果像我这种小白也想要拥有自己的docker镜像，那可行的方法就是通过dockerfile来构建自己的镜像，为什么我们的docker镜像是一层一层的下载呢？因为我们在构建镜像的时候，每一条dockerfile指令可以理解为是一层，也就是说最好的镜像并不是dockerfile指令越多越好，而是越精简越好，相对的镜像的体积也会更小。

dockerfile 常用命令

FROM --指定基础镜像
基础镜像不存在会在docker hub上拉去（一般是文件第一个指令）
使用格式：
FROM <镜像>：[tag]
FROM<镜像>@digest[校验码]
主机没有此镜像时，会自动去hub官网下载

MAINTAINER   提供dockerfile制作者提供本人信息(命令已经逐渐废弃)
LABLE   --代替MAINTANIER
具体使用：
LABLE maintainer="作者信息"
使用的格式
MAINTANIER "redhat66 <zhaolf@aliyun.com>"
LABEL maintainer="***@aliyun.com"
LABEL "com.example.vendor"="ACME Incorporated"

ENV 用于为docker容器设置环境变量，可以使用docker inspect命令来查看。同时还可以使用dock run --env<key>=<value>来修改环境变量
 具体用法：
ENV JAVA_HOME /usr/local/jdk
ENV JRE_HOME $JAVA_HOME/jre
ENV CALLSSPATH $JAVA_HOME/lib/: $JRE_HOME/lib/
ENV PATH $PATH:$JAVA_HOME/bin/

USER
用来切换运行的属主身份，docker默认使用的是root,但若不需要，建议切换使用使用者省份，root权限太大，使用上有安全风险。

WORKDIR
wocker 用来切换工作目录。docker默认的工作目录是/，只有run能执行的CD命令切换目录，也就是说每个run都是独立进行的。如果想让其他指令在指定目录下执行，就靠WORKDIR，WORKDIR动作的目录改变是持久的，不用每个指令使用一次WORKDIR。
具体用法：
WORKDIR /usr/local/tomcat

VOLUME

COPY
ADD
EXPOSE 为容器打开指定的监听端口以实现与外部通信
使格式：
EXPOSE 80/tcp 23/udp
不加协议默认为tcp
使用-P选项可以暴露这里指定的端口！
但是宿主的关联至这个端口的端口是随机的！  
RUN
RUN指令是用来执行命令行命令的不，由于命令行的强大能力，RUN指令在定制镜像时最常用的命令之一，其格式是有2种：
shell格式：RUN<命令> 就像直接 在命令行输入命令一样。刚刚写的dockerfile中的run指令就是这种格式。
exec格式：RUN[“可执行文件”，“参数 1”，“参数2”] 这更像是函数调用中的格式。
使用格式：
RUN<command>
RUN["executable","param1","param2"]
RUN就像shell脚本一样可以执行命令，那么我们是否就可以像shell脚本一样把每个命令对应一个RUN呢？比如：
RUN apt-get update
RUN apt-get install -y gcc libc6-dev make
RUN wget http://dowload.redis.o/releases/redis-4.0.1.tar.gz
RUN tar xzf redis redis-4.0.1.tar.gz
RUN cd redis-4.0.1  //dockerfile中是不成立的，应该使用WORKDIR指令

Dockerfile 中每人个指令都会建立一层，RUN也不也不例外。每一个RUN的行为，和刚才我们手工建立镜像的过程中一样，新建立一层，在其上执行这些命令，执行结束后，commit这一层的修改，构成新的镜像。而上面的这种写法创建了多层的镜像，这是完全没有意义的，而且很多运行时不需要的东西。都安装到了镜像里，比如编译环境，更新的软件包等。结果就是产生非常臃肿、非常多层的镜像，不仅仅增加了构建部署时的时间，也很容易出错。这是很多初学Docker的人经常犯的错误。
Union FS是有最大层数限制的，比如AUFS，曾经是最大不得超过42层的，现在是不得超地过127层。上面的dockerfile正确的写法应该是这样：

以下是我从github上get下来的一段dockerfile写法:

#
 NOTE: THIS DOCKERFILE IS GENERATED VIA "apply-templates.sh"
#
 PLEASE DO NOT EDIT IT DIRECTLY.
#

FROM openjdk:17-jdk-bullseye

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

 #see https://www.apache.org/dist/tomcat/tomcat-10/KEYS
#see also "versions.sh" (https://github.com/docker-library/tomcat/blob/master/versions.sh)
ENV GPG_KEYS A9C5DF4D22E99998D9875A5110C01C5A2F6059E7

ENV TOMCAT_MAJOR 10
ENV TOMCAT_VERSION 10.1.0-M10
ENV TOMCAT_SHA512 ec744e2151a4c9d50728efc0f97a4132e9cbcbf0a643621d7676115d4d59d174bde313512346d52cd53ac1f96ed31e0503e7c430dd61ada35a4c2e70d26e0532

RUN set -eux; \
	\
	savedAptMark="$(apt-mark showmanual)"; \
	apt-get update; \
	apt-get install -y --no-install-recommends \
		ca-certificates \
		curl \
		dirmngr \
		gnupg \
	; \
	\
	ddist() { \
		local f="$1"; shift; \
		local distFile="$1"; shift; \
		local mvnFile="${1:-}"; \
		local success=; \
		local distUrl=; \
		for distUrl in \
#https://issues.apache.org/jira/browse/INFRA-8753?focusedCommentId=14735394#comment-14735394
			"https://www.apache.org/dyn/closer.cgi?action=download&filename=$distFile" \
#if the version is outdated (or we're grabbing the .asc file), we might have to pull from the dist/archive :/
			"https://downloads.apache.org/$distFile" \
			"https://www-us.apache.org/dist/$distFile" \
			"https://www.apache.org/dist/$distFile" \
			"https://archive.apache.org/dist/$distFile" \
#if all else fails, let's try Maven (https://www.mail-archive.com/users@tomcat.apache.org/msg134940.html; https://mvnrepository.com/artifact/org.apache.tomcat/tomcat; https://repo1.maven.org/maven2/org/apache/tomcat/tomcat/)
			${mvnFile:+"https://repo1.maven.org/maven2/org/apache/tomcat/tomcat/$mvnFile"} \
		; do \
			if curl -fL -o "$f" "$distUrl" && [ -s "$f" ]; then \
				success=1; \
				break; \
			fi; \
		done; \
		[ -n "$success" ]; \
	}; \
	\
	ddist 'tomcat.tar.gz' "tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz" "$TOMCAT_VERSION/tomcat-$TOMCAT_VERSION.tar.gz"; \
	echo "$TOMCAT_SHA512 *tomcat.tar.gz" | sha512sum --strict --check -; \
	ddist 'tomcat.tar.gz.asc' "tomcat/tomcat-$TOMCAT_MAJOR/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz.asc" "$TOMCAT_VERSION/tomcat-$TOMCAT_VERSION.tar.gz.asc"; \
	export GNUPGHOME="$(mktemp -d)"; \
	for key in $GPG_KEYS; do \
		gpg --batch --keyserver keyserver.ubuntu.com --recv-keys "$key"; \
	done; \
	gpg --batch --verify tomcat.tar.gz.asc tomcat.tar.gz; \
	tar -xf tomcat.tar.gz --strip-components=1; \
	rm bin/*.bat; \
	rm tomcat.tar.gz*; \
	command -v gpgconf && gpgconf --kill all || :; \
	rm -rf "$GNUPGHOME"; \
	\
#https://tomcat.apache.org/tomcat-9.0-doc/security-howto.html#Default_web_applications
	mv webapps webapps.dist; \
	mkdir webapps; \
#we don't delete them completely because they're frankly a pain to get back for users who do want them, and they're generally tiny (~7MB)
	\
	nativeBuildDir="$(mktemp -d)"; \
	tar -xf 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 \
	; \
	( \
		export CATALINA_HOME="$PWD"; \
		cd "$nativeBuildDir/native"; \
		gnuArch="$(dpkg-architecture --query DEB_BUILD_GNU_TYPE)"; \
		aprConfig="$(command -v apr-1-config)"; \
		./configure \
			--build="$gnuArch" \
			--libdir="$TOMCAT_NATIVE_LIBDIR" \
			--prefix="$CATALINA_HOME" \
			--with-apr="$aprConfig" \
			--with-java-home="$JAVA_HOME" \
			--with-ssl=yes \
		; \
		nproc="$(nproc)"; \
		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 > /dev/null; \
	find "$TOMCAT_NATIVE_LIBDIR" -type f -executable -exec ldd '{}' ';' \
		| awk '/=>/ { print $(NF-1) }' \
		| xargs -rt readlink -e \
		| sort -u \
		| xargs -rt dpkg-query --search \
		| cut -d: -f1 \
		| sort -u \
		| tee "$TOMCAT_NATIVE_LIBDIR/.dependencies.txt" \
		| xargs -r apt-mark manual \
	; \
	\
	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|' '{}' +; \
	\
#fix permissions (especially for running as non-root)
#https://github.com/docker-library/tomcat/issues/35
	chmod -R +rX .; \
	chmod 777 logs temp work; \
	\
#smoke test
	catalina.sh version

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

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

构建docker镜像：案例1
需求：创建一个镜像（基于tomcat）里面要有一个index.html，并写入hello docker file
1、在宿主机创建一个空白目录

mkdir -p /usr/local/docker/demo1

2、在该目录下，创建一个文件dockerfile

vim Dockerfile

3、其内容为：

FROM tomcat //指定tomcat最新版本的镜像
RUN mkdir -p /usr/local/tomcat/webapps/ROOT
RUN echo ‘hello docker’>/usr/local/tomcat/webapps/ROOT/index.html
WORKDIR /usr/local/tomcat/webapps/

4、构建镜像

docker build -t demo1 .    //dockerfile 的上下文路径

5、运行镜像所在的容器

docker run --rm --name demo1-8080 -p 8080:8080 -d demo1

构建docker：案例2
需求：基于上一个镜像（）基于tomcat 将ROOT内多余的文件都删除。只保留index.html
1、基于如上修改dockerfile

FROM tomcat  //指定最新的tomcat最新版本镜像
WORKDIR /usr/local/tomcat/webapps/ROOT/    //切换到该目录下
RUN rm -rf *  //将该目录的文件删除掉
RUN echo 'hello docker' >/usr/local/tomcat/webapps/ROOT/index.html

2、构建镜像

docker build -t 镜像名 .    //dockfiler的路径

3、查看镜像列表docker images

docker images

4、删除虚拟镜像

docker image prune

构建docker镜像：案例3
需求：基于上一个镜像（基于tomcat)外部复制一个文件（图片）并复制到容器中并能访问
1、基于如上修改dockerfile

FROM tomcat  //指定tomcat 最新版本镜像
WORKDIR /usr/local/tomcat/webaps/ROOT/    //切换到该目录下
RUN rm -rf *     //将当前目录文件都删除
COPY 1.PNG  /usr/local/tomcat/webapps/ROOT/    //将图片复制到容器内部的容器
RUN echo 'hello docker '> /usr/local/tomcat/webapps/ROOT/index.html

2、构建镜像

docker build -t 镜像名 .      //dockerfile 上下文路径

构建docker镜像：案例4
实际的开发中，利用dockerfile将一个war包生成镜像的dockerfile
1、docker 下创建项目工程名称

mkdir -p /usr/local/docker/qfjy_exam
cd /usr/local/docker/qfjy_exam

2、将桌面qfjy_exam.zip复制到访问目录下

cp qfexam-1.0-sanpshot.zip /usr/local/docker/qfjy_exam

3、创建镜像文件dockerfile

FROM tomcat
WORKDIR /usr/local/tomcat/webapps/ROOT  //指定工作目录
RUN rm -rf *  //删除指定目录的所有内容文件
COPY qfjy_exam-1.0-snpshot.zip /usr/local/tomcat/webapps/ROOT/  
RUN unzip qfjy_exam-1.0-snapshot.zip    解压文件
RUN rm -rf qfjy_exam-1.0-snapshot.zip    移除多余的压缩包
WORKDIR /usr/local/tomcat  //指定回工作目录

4、构建镜像

docker build -t qfjy_exam .  //指定当前dockerfile的路径

5、进入容器内部查看

docker run -it qfjy_exam bash

项目部署
war（传统SSM）常用linux文件复制的文件完成部署
jar（SpringBoot微服务）需要用docker方式来部署完成

SpringBoot部署docker
1、准备好一个基于springboot项目
2、mvn package install -->sprigboot.jar
3、windows系统：java -jar springboot.jar (内置tomcat)
4、linux系统完成微服务项目部署
linux系统中安装好JDK （环境变量）
jar -jar springboot.jar
有个注意事项：linux中 jar -jar springboto (仅能java -jar)如果执行多个java -jar 将旧的退出
nohup java -jar springboot.jar nohub java -jar springbot1.jar

springboot部署docker完成过程
springboot.jar 复制到linux目录下
通过定制镜像的方式来完成微服务架构的构建（镜像）
通过运行多个容器来实现高可用、高并发等快速部署流程。
1、准备springboot jar项目
dockefile
FROM java：8 //指定基于镜像，即运行环境
VOLUME /tmp ///tmp创建/tmp目录并持久化到docker数据文件夹，因为spring boot使用的内嵌的tomcat容器默认使用/tmp作为工作目录
ADD exam-0.0.1-SNAPSHOT.jar exam.jar //拷贝文件并重命名
EXPOSE 8080 不是真的发布端口，是容器部署人员与建立image人员之间的交流，即建立image人员告警容器部署人员容器应该映射哪个端口给外界。
ENTRYPONTION[“java”,"-Djava.security.egd=file:/dev/./urandom","-jar","/exam.jar"] 容器启动时运行的命令，相当于我们在命令行输入 java -jar xxx.jar，为了缩短tomcat的启动时间，添加java.security.egd的系统属性指向/dev/urandom作为ENTRYPOINT
2、构建容器

docker build -t exam .

3、运行容器

docker run -d -n springboot1 -p 8080:8080 exam  --rm   把容器跑起来，--rm（容器一停掉之后就删除掉）

四、docker图形化工具的使用

docker图形页面管理工具常用的有三种，DockerUI，Portainer，Shipyard。DockerUI是Portainer的前身。这三个工具通过docker api 来获取管理的资源信息。平时我们常常对shell对着这一些命令客户端，审美会很疲劳，如果有漂亮的图形化界面可以直观的查看 docker资源信息，是非常方便的。这三种工具当中。portainer最为受欢迎。
portainer 图形化工具
1、查看 portainer镜像

docker search portainer

2、portainer 镜像下载

docker pull portainer  /portainer

3、启动dockerui容器

docker run -d --name portainerUI -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer /portainer

4、浏览器访问

http://1.1.1.1:9000/

五、Docker-compose使用

前面我们使用docker的时候，定义dockerfile文件，然后使用docker build、docker run -在–name -p 等命令操作容器。然而微服务架构的应用系统一般包含若干个微服务，每一个微服务一般会部署多个实例，如果第一个微服务都要手动的启停，那效率极低、维护量之大可想而知。
使用docker compose 可以轻松、高效的管理容器，它是一个用于定义和运行多容器的docker应用程序工具。docker compose 是docker官方编排的项目之一，负责快速的部署分布式应用。
compose项目是docker官方的开源项目，负责实现对docker容器集群的快速编排。从功能上看，跟openstack中的Heat十分类似。其代码在https://github.com/docker/compose上开源。
compose定位是【定义和运行多docker容器的应用】其前身是开源项目Fig
通过第一部分中的介绍，我们知道一个dockerfile模板文件，可以让用户很方便的定义一个单独的应用容器。然而，在日常工作中，经常会碰到需要多个容器相互配合来完成某项任务的情况。例如要实现一个web项目，除了web服务器本身，往往还需要加上后端的数据库服务容器，甚至还包括负载均衡容器。
compose恰好满足了这样的需求。它允许用户通过一个单独的docker-compose.yml模板文件（YAML格式）来定义一组相关联的应用容器的一个项目
compose中有2个重要的概念。
服务（service）：一个应用的容器，实际上可以包括若干个运行相同镜像的容器实例。
项目（project）：由一组关联的应用容器组成的一个完整的业务单元，在dock-compose.yml文件中定义。
compose的默认管理对象是项目，通过子命令对项目中一组容器进行便捷地进行生命周期管理。
compose项目由python编写，实现上调用docker服务提供的api来对容器进行管理。因此，只要所操作的平台支持docker API，就可以在其上复用compose来进行编排管理。

Docker Compose的安装与卸载
compose支持linux、macOS、windows10三大平台。
compose可以通过python的包管理工具pip进行安装，也可以直接下载编译好的二进制文件使用，甚至能直接在docker 容器中运行。
Docker for mac、Docker for windows 自带的docker-compose
二进制文件，安装docker之后可以直接使用。
官方安装：
1、github官方网站，搜索docker compose
2、找到下载好二进制文件

https://github.com/docker/compose/releases/download/1.25.5/docker-compose-Linux-x86_64

2.1、将下载好的文件拖入linux并剪切到/usr/local目录下

mv docker-compose-Linux-x86_64 /usr/local

2.2、修改名称（为后面方便调用）并修改其为可执行文件

mv docker-compose-Linux-x86_64 /usr/local
chmod 777 docker-compose
mv docker-compose /usr/local/bin

Docker Compose使用
服务（service）：一个应用容器，实际上可以运行多个相同的镜像实例。
项目（project）：由一组关联的应用容器组成一个完整的业务单元。
由此可见，一个项目可以由多个服务（容器）关联面成，compose而面向项目进行管理。
Docker-compose创建容器
通过一个单独的docker-compose.yml模板文件（YAML格式）来定义一组关联的应用容器为一个项目（project）.
yml格式描述：
1、yml文件以缩进代表层级关系
2、缩进不允许使用tab只能使用空格
3、空格的个数不重要，只要相同的层级的元素左对齐即可（建议2个）
4、大小写敏感
5、数据格式为名称:空格(值)
一、k: 空格v:表示一对键值对（空格不能省略），以空格控制层级关系，只要是左对齐的数据，都是同一级别;

server：
  port:8083
   path:/helloboot

二、数组（用-表示数组中的一个元素）

animal:
-cat
-dag

示例1：
1、管理文件夹，创建相应的目录

mkdir -p /opt/docker_mysq_tomcat

2、在如上目录中，编写创建docker-compose.yml配置文件
编写docker-comose.yml文件，这个是compos使用的主模板文件。

version:'3.1'
services：
    myql:
       restart:always
       images:daocloud.io/librarymysql:5.7.6
       container_name:mysql-3306
       ports:
           -3306:3306
       environment:
            MYSQL_ROOT_PASSWORD:root
            TZ:Asiz/Shanghai
       -  /opt/docker_mysql1_tomcat/mysql/data:/var/lib/mysql 
      -  /opt/docker_mysql_tomcat/mysql/conf/mysqld.cnf:/etc/mysql/mysql.conf.d/mysqld.cnf

    tomcat:
       restart:always
       image:daocloud.io/libraty/tomcat:8.5.15-jre8
       container_name:tomcat-8080
       ports:
          -8080:8080
       environment:
          TZ:Asiz/Shanghai
       volumes:
          -  /opt/docker_mysql_tomcat/tomcat/webapps:/usr/local/tomcat/webapps
          -  /opt/docker_mysql_tomcat/tomcat/logs:/usr/local/tomcat/logs

3、启动（执行命令创建容器）

docker-compose -f 文件名.后缀名 up -d 
默认执行的文件名：docker-compose.yml （且城在当前上下文路径中）。如果文件名不是默认的需要使用正面的指令:
docker-compose -f 文件名.后缀名 up -d

需求：实现通过docker-compose批量部署容器

mkdir -p  /opt/docker-cluster
cd /opt/docker-cluster
vim docker-compose.yml

内容：

version:'3.1'
services:
   docker1:
restart:always
images:tomcat
container_name:tomcat
ports:
 - 8080:8080

   docker2:
restart:always
images:tomcat
container_name:tomcat
ports:
 - 8080:8080
   docker3:
restart:always
images:tomcat
container_name:tomcat
ports:
 - 8080:8080

4、上线应用

docker-compose up -d dock.yml      //如果dock.yml文件不是当前目录，需要加上路径

5、容器操作

docker-compose up -d 启动容器 （当前目录docker-compose.yml）
docker-compose stop 关闭容器
docker-compose down  关闭容器并删除所有容器

〆是凌风呀

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Docker基础学习

dock基础
复制链接

扫一扫

专栏目录