docker

笑瘾

已于 2022-08-26 19:31:57 修改

阅读量932

点赞数 1

分类专栏：云原生文章标签： docker linux 运维

于 2022-08-16 20:10:13 首次发布

本文链接：https://blog.csdn.net/weixin_47661174/article/details/126356801

版权

云原生专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、docker的介绍

1、docker的定义：是一个容器管理软件，使用go语言开发的，对容器进行管理
2、和虚拟机相比，docker有哪些优缺点

优点：
1.启动速度快
2.资源消耗小，资源可以控制
3.扩展方便，特别是使用了k8s以后

缺点：
1.app的隔离这块，没有虚拟机彻底，安全性没有虚拟机高
2.层次方面，虚拟机多了封装了一层

3、容器的单进程思想：一个容器里只跑一个关键的进程
4、介绍镜像、容器、仓库

镜像：app的封装，里面有一些程序代码，基础系统、依赖库、工具等
容器：镜像运行的一个场所，一个容器启动相当于一个进程在运行
仓库：存放镜像的地方

二、docker的安装

1.卸载旧版本的docker
		yum remove docker \
	                  docker-client \
	                  docker-client-latest \
	                  docker-common \
	                  docker-latest \
	                  docker-latest-logrotate \
	                  docker-logrotate \
	                  docker-engine
2.添加yum仓库文件
[root@lhj-docker ~]# yum install -y yum-utils
添加docker官方的yum仓库文件，一会儿我们需要去docker官方的yum仓库下载软件
	[root@lhj-docker ~]# yum-config-manager \
	     --add-repo \
	     https://download.docker.com/linux/centos/docker-ce.repo

添加阿里云的镜像docker仓库
	[root@lhj-docker ~]# yum-config-manager     --add-repo     http://mirrors.aliyun.com/docker-	ce/linux/centos/docker-ce.repo

	[root@lhj-docker ~]# cd /etc/yum.repos.d/ 		存放所有的yum仓库文件的
	[root@lhj-docker yum.repos.d]# ls
		CentOS-Base.repo                     CentOS-Linux-FastTrack.repo
		CentOS-Linux-AppStream.repo          CentOS-Linux-HighAvailability.repo
		CentOS-Linux-BaseOS.repo             CentOS-Linux-Media.repo
		CentOS-Linux-ContinuousRelease.repo  CentOS-Linux-Plus.repo
		CentOS-Linux-Debuginfo.repo          CentOS-Linux-PowerTools.repo
		CentOS-Linux-Devel.repo              CentOS-Linux-Sources.repo
		CentOS-Linux-Extras.repo             docker-ce.repo

3.安装docker
	[root@lhj-docker yum.repos.d]# yum install docker-ce docker-ce-cli containerd.io -y
4.启动docker，并且设置docker开机自启动
	[root@lhj-docker yum.repos.d]# systemctl start docker
	[root@lhj-docker yum.repos.d]# systemctl enable docker
		Created symlink /etc/systemd/system/multi-user.target.wants/docker.service → /usr/lib/systemd/system/docker.service.
5.查看docker是否启动
	[root@lhj-docker yum.repos.d]# ps aux|grep docker
		root       12515  0.1  2.0 1366792 79768 ?       Ssl  11:41   0:00 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
		root       12669  0.0  0.0  12348  1068 pts/0    S+   11:42   0:00 grep --color=auto docker
6.测试运行一个docker容器
	[root@lhj-docker yum.repos.d]# docker run hello-world
		Unable to find image 'hello-world:latest' locally
		latest: Pulling from library/hello-world
		2db29710123e: Pull complete 
		Digest: sha256:bfea6278a0a267fad2634554f4f0c6f31981eea41c553fdf5a83e95a41d40c38
		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/

三、docker常用命令

1、docker version  查看docker的版本
1、docker info	 查看docker的详细信息
2、docker images  查看自己的docker里有那些镜像
3、docker search 	搜索doucker镜像
	docker search nginx  查找nginx镜像
	docker search mysql  查找mysql镜像
4、docker pull  下载docker镜像
	docker pull mysql 		  下载mysql镜像，默认是下载最新版本的
	docker pull mysql:5.7.37   下载指定版本的mysql镜像，5.7.37
5、docker ps    查看有多少容器正在运行
6、docker ps -a  查看有多少容器，没有运行的也显示出来
7、dokcer stats   查看容器的使用情况
6、docker run 	启动某个容器，第一次启动
	docker run -d -p 8090:80 --name  sc-nginx  nginx
		-d 在后台运行 daemon 守护进程
		-p 8090:80  指定端口映射    DNAT 访问本机的8090端口，转发到docker容器的80端口
		--name  sc-nginx  指定容器的名字
 		nginx 是镜像的名字
7、docker  stop 停止某个容器
	docker stop lhj-nginx-3   停止lhj-nginx-3这个容器
8、docker start  启动某个容器
	docker start lhj-nginx-3   启动运行lhj-nginx-3这个容器
9、docker rm 删除某个容器
	docker rm lhj-nginx  删除lhj-nginx容器
10、docker rmi  删除某个镜像，还要指定版本
	docker rmi mysql：latest  删除mysql：latest镜像
11、ps aux|grep containerd-shim--》查看docker里有多少容器正在运行
12、docker logs	查看容器日志，当容器启动不起来，它会给予相应的提醒，还可以用来排错
	docker logs centos7-lhj-1		查看centos7-lhj-1这个容器的日志
13、docker create --name sc-lhj-1 -p 8090:80 nginx		创建静态的容器
14、docker exec -it sc-lhj-1 /bin/bash		进入容器的内部
	docker exec    进入容器内部
	-it            开启一个交互式的中端，进入容器里面，运行/bin/bash
15、docker inspect	查看容器的详细信息
	docker inspect sc-lhj-1  查看sc-lhj-1这个容器的详细信息
16、docker network ls  查看容器使用的网络类型
17、docker registry/harbor   搭建私有仓库
18、docker cp	可以实现容器和宿主机里面文件的相互拷贝
	docker cp re.txt sc-nginx:/root 
			复制r宿主机里re.txt到容器sc-nginx的家目录下面

四、数据卷

1、数据卷：实现容器和宿主机之间共享数据的，使容器里的数据保存到磁盘里，达到数据的持久化
2、正常的停止容器，容器里的数据不会丢失，会保存在/var/lib/docker/volumes
3、数据卷里的相关操作和命令

docker volume create sc  创建卷，名为sc
docker volume ls  查看卷
docker volume inspect sc  查看卷的详细信息和路径

4、启动容器去使用卷

docker run -d --name  lhj-2 --mount source=sc,target=/usr/share/nginx/html -p 7790:80  nginx:latest

五、容器的相关知识

1、容器的状态

1.up
2.created
3.exited

2、启动一个mysql容器

1.安装数据库：yum install mariadb mariadb-server
	mariadb  是客户端的软件包
	mariadb-server  是服务器的软件包
2.启动mysql的容器：docker run --name lhj-mysql-1 -e MYSQL_ROOT_PASSWORD='123456' -d -p 3306:3306 mysql:5.7.37
	-e     宿主机往容器里传递环境变量  environment
	MYSQL_ROOT_PASSWORD    是变量名
	123456		   是变量值（设置密码）
3.访问：mysql -h 192.168.243.135 -uroot -p123456
	可以使用安装了mysql客户端的其他机器去访问
	-h  指定连接服务器的ip地址

3、解决容器上不了网的问题

1、临时开启路由功能：
		echo 1 >/proc/sys/net/ipv4/ip_forward
		service docker restart     重启docker，会到iptables里去添加相关规则
2、永久开启路由功能：
		[root@lhj-docker ~]# vim /etc/sysctl.conf	#修改内核参数的配置文件
		新添加一个内容：net.ipv4.ip_forward = 1
		[root@lhj-docker ~]# sysctl -p  #刷新配置
		net.ipv4.ip_forward = 1

4、限制容器可以使用的cpu和内存资源

docker run -it --cpu-shares 30 -m 100000000 -d --name centos-lhj-2 centos:7
	--cpu-shares 30  限制使用cpu
	-m 100000000     限制内存 默认单位是byte

cpu的计量单位：
  cpu的计量单位叫豪核。假如一个服务器有两个核，那么该服务器的CPU总量为2000m。如果你要使用单核的十分之一，则你要求的是100m，要是使用总核的十分之一，则你的要求是200m；
  这个m的单位，是将一个cpu内核抽象化，分成1000等份。每一份即为一个millicore，即千分之一个核，或毫核。跟米与毫米的关系是一样的。

5、将容器挂载在宿主机上

docker run -d --name lhj-1 -p 7789:80 -v /sc-web:/usr/share/nginx/html nginx
		docker run 启动容器
		-d  在后台启动一个容器进程 deamon
		--name lhj-1  指定启动容器的名字
		-p 端口的映射：iptables的DNAT 7789：80 访问宿主机的7789端口，转发到容器里的80端口
		-v /sc-web:/usr/share/nginx/html  
			数据卷：可以实现宿主机和容器直接的数据共享
			第一个/sc-web 是宿主机里的目录
			第二个/usr/share/nginx/html 是容器里的系统的目录
		nginx  表示启动的是nginx服务

6、容器的网络类型

1、容器的五种网络类型
	1.bridge，桥接模式
	2.host模式：
	容器和宿主机共享ip地址，端口号要区别开
	3.none模式：
	只有lo接口，没有其他的接口
	4.container模式：
	很多容器共享一个ip地址（k8s里就是采用这种模式，来管理pod）
	5.overlay：	
	实现跨主机的docker容器通信的
2、查看容器里的网络类型
	docker network ls
3、创建新的网络命名空间，模式为桥接，名为sc
	docker network create --driver bridge sc
4、创建一个容器，使用你创建的那个网络命名空间
	docker run -it -d --name lhj-centos-1 --network sc centos:7

7、容器内部的相关文件

1、bootfs --》容器启动的时候需要的内容
	容器启动的时候，内核启动bootfs后直接将基础镜像加载，然后一层一层的加载--》自上而下
2、rootfs --》容器内部的操作系统
	容器运行后访问文件的时候，自上而下，从可写层，一层一层往下访问

六、镜像

1、镜像：是一个app的封装，里面有程序代码，基础系统，依赖库，工具
2、制作镜像的流程

1.新建一个空目录
	[root@lhj-docker ~]# mkdir /mydocker
	[root@lhj-docker ~]# cd /mydocker/

2.新建Dockerfile
	[root@lhj-docker mydocker]# vim Dockerfile
	#下载一个python2.7的镜像模板，已经有操作系统和安装好python2.7
	FROM python:2.7-slim
	# 在docker容器里的工作目录--》进入docker容器的时候，所在的目录
	WORKDIR /app
	#复制当前目录下的所有内容到容器里的/app目录下
	ADD . /app
	#设置一个卷轴
	VOLUME ["/data_flask"]
	#安装requirements.txt里的库,只是在制作镜像的时候运行
	RUN pip install --trusted-host pypi.python.org -r requirements.txt
	#暴露80端口-->发布80端口
	EXPOSE 80
	#设置环境变量
	ENV NAME World
	ENV AUTHOR lhj
	#进入容器时的执行的命令，容器启动时就会执行
	CMD ["python","app.py"]
3.新建requirements.txt文件
	[root@lhj-docker mydocker]# vim requirements.txt
	[root@lhj-docker mydocker]# cat requirements.txt 
	Flask
	Redis
4.新建app.py文件，我们的程序文件
	[root@lhj-docker mydocker]# cat app.py 
	from flask import Flask
	from redis import Redis, RedisError
	import os
	import socket

	# Connect to Redis
	redis = Redis(host="redis", db=0, socket_connect_timeout=2, socket_timeout=2)

	app = Flask(__name__)

	@app.route("/")
	def hello():
	    try:
	        visits = redis.incr("counter")
	    except RedisError:
	        visits = "<i>cannot connect to Redis, counter disabled</i>"

	    html =  "<h3>Hello {name}!</h3>" \
	            "<b>Hostname:</b> {hostname}<br/>" \
	            "<b>Visits:</b> {visits}"
	    return html.format(name=os.getenv("NAME","world"), hostname=socket.gethostname(), visits=visits)

	if __name__ == "__main__":
	    app.run(host='0.0.0.0', port=80)
5.生成镜像，需要一点时间，因为下载安装很多东西
	[root@lhj-docker mydocker]# docker build -t sc_friendlyhello_1 .
		-t sc_friendlyhello_1    给镜像起一个名字，叫sc_friendlyhello_1
		一定要注意后面那个点，因为生成镜像会在当前文件夹里面去寻找Dockerfile文件的
6.查看镜像
	[root@lhj-docker mydocker]# docker images
	REPOSITORY                 TAG        IMAGE ID       CREATED         SIZE
	sc_friendlyhello_1         latest     7c4a668ab20a   6 minutes ago   159MB
	python                     latest     403fd3ce9d68   2 days ago      919MB
	mysql                      5.7.37     f26e21ddd20d   2 weeks ago     450MB
	redis                      latest     bba24acba395   2 weeks ago     113MB
	nginx                      latest     12766a6745ee   2 weeks ago     142MB
7.使用镜像，运行容器
	[root@lhj-docker mydocker]# docker run -d -p 5080:80 --name sc-hello-1 sc_friendlyhello_1
	c6abcafba5328bf01e4bd665901ebc5362018e477935bfa4f3807602927ce7f1
8.访问容器的web服务
	curl或者用浏览器访问
	宿主机ip：5080

Hello World!
Hostname: c6abcafba532
Visits: cannot connect to Redis, counter disabled

因为redis数据库容器没有启动，flask web服务不能连接到redis数据库

9.启动redis容器
	docker run -d -p 6379：6379 --name sc-redis-1 redis
10.再次启动一个自己制作镜像的容器，链接到redis容器
	[root@lhj-docker mydocker]# docker run -d --name sc-hello-2 -p 5081:80 --link 	sc-redis-1:redis sc_friendlyhello_1
		c98e512db96087bfa704f0e7722488a08acec48e13504fbcc5a34be9ae62bd72
11.再次访问容器的web服务
	curl或者用浏览器访问
	宿主机ip：5081

Hello World!
Hostname: c98e512db960
Visits: 8

12.查看容器里的环境变量，在Dockerfile里定义的
	[root@lhj-docker mydocker]# docker exec -it sc-hello-2 /bin/bash
	root@c98e512db960:/app# echo $NAME
	World
	root@c98e512db960:/app# echo $AUTHOR
	lhj

3、练习需求：

1.以centos7作为基础镜像
2.在里面安装好ip ，vim，ping命令
3.编译好nginx，使用我们指定的配置文件nginx.conf
4.启动容器的时候，就启动nginx
5.网页代码上传到容器里：
	5.1 直接做到镜像里
	5.2 使用数据卷挂载使用
		/usr/local/nginx1/html


1.准备环境，新建目录
	[root@lhj-docker ~]# cd /mydocker/
	[root@lhj-docker mydocker]# ls
	app.py  Dockerfile  getting-started  requirements.txt
	[root@lhj-docker mydocker]# mkdir nginx
	[root@lhj-docker mydocker]# cd nginx
	[root@lhj-docker nginx]# pwd
	/mydocker/nginx
准备安装nginx的脚本和nginx的源码文件
下载nginx的源码文件：curl -O https://nginx.org/download/nginx-1.21.6.tar.gz
	[root@lhj-docker nginx]# ls
	Dockerfile  install_nginx.sh  nginx-1.21.6.tar.gz
安装nginx的脚本：install_nginx.sh
	#!/bin/bash

	#解决软件的依赖关系，需要安装的软件包
	yum -y install zlib zlib-devel openssl openssl-devel pcre pcre-devel gcc gcc-c++ autoconf automake make
	#下载nginx
	mkdir -p /nginx
	cd /nginx
	#解压下载的nginx的源码包
	curl -O https://nginx.org/download/nginx-1.21.6.tar.gz
	tar xf nginx-1.21.6.tar.gz
	cd nginx-1.21.6
	#生成编译前配置工作--》Makefile
	./configure --prefix=/usr/local/nginx1 --with-threads --with-http_ssl_module --with-http_realip_module --with-http_v2_module --with-file-aio --with-http_stub_status_module --with-stream
	#编译
	make
	#编译安装--》将编译好的二进制程序安装到指定目录/usr/local/nginx1
	make install


2.编写Dockerfile文件
	[root@lhj-docker nginx]# cat Dockerfile 
	FROM centos:7
	ENV NGINX_VERSION 1.21.6
	ENV AUTHOR lhj
	LABEL maintainer="<2331422322@qq.com>"
	RUN mkdir /nginx
	WORKDIR /nginx
	COPY . /nginx
	RUN set -ex; \
	    bash install_nginx.sh ; \
	    yum install vim iputils net-tools iproute -y
	EXPOSE 80
	ENV PATH=/usr/local/nginx1/sbin:$PATH
	STOPSIGNAL SIGQUIT
	CMD ["nginx","-g","daemon off;"]
3.生成我们的镜像
	[root@lhj-docker nginx]# docker build -t sc-nginx:1.0 .

	[root@lhj-docker nginx]# docker images
	REPOSITORY                 TAG         IMAGE ID       CREATED          SIZE
	sc-nginx                   1.0         14bf6a489e61   10 seconds ago   583MB
4.启动容器，使用我们自己编译的镜像
	[root@lhj-docker nginx]# docker run -dp 3390:80 --name sc-lhj-nginx-1 sc-nginx:1.0
	9967592e8702287258da453f535746191e255c0d71c9b09d00b6e23b17c29b73
	[root@lhj-docker nginx]# docker ps
	CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                   NAMES
	9967592e8702   sc-nginx:1.0   "nginx -g 'daemon of…"   7 seconds ago   Up 5 seconds   0.0.0.0:3390->80/tcp, :::3390->80/tcp   sc-lhj-nginx-1
5.去测试访问web服务
	curl 192.168.243.135：3390

4、镜像的导出和导入

1、静态的导出和导入
	1、docker save -o sc-ubuntu.tar ubuntu  在不运行的容器里，静态的导出镜像
	2、scp sc-ubuntu.tar root@192.168.0.17:/root  通过scp命令传递给另一台服务器上
	3、docker load -i sc-ubuntu.tar  在另外一台服务器上导入镜像
2、动态的导出和导入
	1、docker export -o sc-ubuntu2.tar ubuntu-liu-4  在运行的容器里，动态的导出镜像
	2、scp sc-ubuntu2.tar root@192.168.0.17:/root  通过scp命令传递给另一台服务器上
	3、docker import sc-ubuntu2.tar sc-ubuntu.tar：2.0  在另外一台服务器上导入镜像

5、容器使用宿主机里的网站数据，有几种方式实现

1.使用volume的方式来解决
	[root@lhj-docker nginx]# docker run -dp 3391:80 -v /sc-web:/usr/local/nginx1/html --name sc-lhj-nginx-2 sc-nginx:1.0
	e7c64c849f0c8348341f661c512f7b2a3e6977446fac0ddd22d16233942910a8
	[root@lhj-docker nginx]# docker ps
	CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                                   NAMES
	e7c64c849f0c   sc-nginx:1.0   "nginx -g 'daemon of…"   4 seconds ago    Up 3 seconds    0.0.0.0:3391->80/tcp, :::3391->80/tcp   sc-lhj-nginx-2


2、创建volume liuhongjie
[root@lhj-docker nginx]# docker volume create liuhongjie
	liuhongjie
[root@lhj-docker nginx]# docker volume ls
	DRIVER    VOLUME NAME
	local     cdd9a9f82c6ba20cd51293379b36c3494c5c29d855773e62082cff14a0e86cbb
	local     db31064aaf30dbe41dbb8be8b700f3b12655a7b1b03ebcd87d4e9adaeb90b9cd
	local     liuhongjie
	local     sc
[root@lhj-docker nginx]# docker volume inspect liuhongjie
	[
	    {
	        "CreatedAt": "2022-04-19T13:41:28+08:00",
	        "Driver": "local",
	        "Labels": {},
	        "Mountpoint": "/var/lib/docker/volumes/liuhongjie/_data",
	        "Name": "liuhongjie",
	        "Options": {},
	        "Scope": "local"
	    }
	]
拷贝/sc-web下的网页的内容到数据卷liuhongjie对应的目录下
[root@lhj-docker nginx]# cp /sc-web/  /var/lib/docker/volumes/liuhongjie/_data/ -r
启动容器使用数据卷
[root@lhj-docker nginx]# docker run -dp 3392:80 --name sc-lhj-nginx-3 --mount source=liuhongjie,target=/usr/local/nginx1/html sc-nginx:1.0
	20bc5a60b5b59c588408dc918193abcee47267561790191729b10447589dbab0
[root@lhj-docker nginx]# docker ps
	CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                                   NAMES
	20bc5a60b5b5   sc-nginx:1.0   "nginx -g 'daemon of…"   4 seconds ago    Up 3 seconds    0.0.0.0:3392->80/tcp, :::3392->80/tcp   sc-lhj-nginx-3
	e7c64c849f0c   sc-nginx:1.0   "nginx -g 'daemon of…"   9 minutes ago    Up 9 minutes    0.0.0.0:3391->80/tcp, :::3391->80/tcp   sc-lhj-nginx-2
	9967592e8702   sc-nginx:1.0   "nginx -g 'daemon of…"   19 minutes ago   Up 19 minutes   0.0.0.0:3390->80/tcp, :::3390->80/tcp   sc-lhj-nginx-1

七、docker相关的重要知识点

1、docker里的相关的进程

1.docker-proxy：这个进程是专门负责端口映射（监听端口的）
2.dockerd：提供docker server的进程
3.containerd：整个容器的管理进程
4.containerd-shim-runc-v2：具体某个容器对应的进程

2、docker底层的隔离机制

1、name space 命名空间--》Namespace是内核的一个功能，用来给进程隔离的一系列系统资源的，例如：网络，文件系统，进程等
2、Control Groups（cgroups）--》对资源进行限制，例如：cpu，内存，磁盘，带宽等

3、docker里常见的文件及作用

1.config.v2.json：存放着容器的配置的数据
2.resolv.conf：容器里的DNS服务器的地址使用的是宿主机里的dns的配置
3.hostname：存放container ID的
4.hosts：域名解析
5./var/lib/docker/containers：存放容器的目录
6./var/lib/docker：存放docker的目录

4、docker内部有多少种命名空间

1、network命名空间
2、进程命名空间、
3、IPC命名空间
4、挂载命名空间、
5、UTS命名空间
6、用户命名空间

笑瘾

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录