docker学习

最新推荐文章于 2024-02-03 23:58:35 发布

落月爱学习

最新推荐文章于 2024-02-03 23:58:35 发布

阅读量105

点赞数

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

本文链接：https://blog.csdn.net/qq_54202620/article/details/131802750

版权

运维专栏收录该内容

4 篇文章 0 订阅

订阅专栏

docker

简介

l.Docker 是一个开源的应用容器引擎，基于 Go 语言并遵从 Apache2.0 协议开源。

Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

2.Docker 的主要目标是build ，ship and run any app，anywhere’，也就是说通过对应用程序组件的封装，分发，部署，运行等生命周期的管理。使用户的 app (可以是一个 web 应用程序或者数据库应用等) 及其运行环境能够做到一次封装，到处运行’。

3.Linux 容器技术的出现解决了这个问题。而 docker 就是基于他的基础上发展过来的。将应用运行到 docker 容器上面，而 docker 容器在任何操作系统上都是一致的，这就是实现跨平台跨服务器。只需要一次配置好环境,换到别的机子上就可以一键部署好，大大简化了操作.

4.容器是完全使用沙箱机制，相互之间不会有任何接口(类似 iPhone 的 app).更重要的是容器性能开销极低。

5.Docker 从 17.03 版本之后分为 CE (Community Edition: 社区版) 和 EE (EnterpriseEdition: 企业版)，我们用社区版就可以了。**

Docker 实际上就是一个虚拟化容器，可以解决我们在开发环境中运行配置问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fAs0Er8g-1689733288789)(/Users/apple/Library/Application Support/typora-user-images/image-20230711145501743.png)]

使用 docker 的好处

1，简化配置安装创建非常的方便

2.代码流水线(Code Pipeline) 管理传统项目部署可能需要经过很多环节，容易产生版本的依赖冲突问题，Docker 给应用提供了一个从开发到上线均一致的环境，让代码的流水线变得简单不少 SIT PRE PRD

3.Devops 开发与运维一体化减少沟通的成本( docker 或者是 k8s 实现)

4.虚拟技术快速部署

5.弹性扩容

docker三大核心要素

1.仓库

专门存放我们的镜像文件类似于腾讯管家软件市场、app 软件市场

2.镜像

类似于安装包描述运行所需要的环境配置和依赖 Redis 镜像、tomcat 镜像
方式来源

springboot 项日 (自己创建一个镜像文件)
DOCKERhub 仓库下载
Docker 公开仓库地址： Docker hub

https://hub.docker.com/

Docker官方仓库：https://hub.docker.com/ ----访问比较慢

3.容器

运行我们镜像文件自己独立的ip 和网络信息虚拟化出一个轻量级的linux操作系统精简版本。

docker架构设计原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7nL6m0I2-1689733288791)(/Users/apple/Library/Application Support/typora-user-images/image-20230711150706046.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KwIMSY0F-1689733288792)(/Users/apple/Library/Application Support/typora-user-images/image-20230711150830064.png)]

容器和虚拟机的区别

什么是虚拟机

在一台物理机器上，利用虚拟化技术，虚拟出来多个操作系统，每个操作系统之间是隔离的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hK2rrNw1-1689733288793)(/Users/apple/Library/Application Support/typora-user-images/image-20230711152717691.png)]

什么是docker

docker是开源性的应用容器引擎

最下面两层，概念同上。往上，可以看做 Docker 容器的管理器。依赖和应用都被打包成了 Docker 镜像。例如，JDK、Tomcat、应用都被打包在了一起，运行在 Docker 容器里，容器和容器间是隔离的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TZeoylnz-1689733288794)(/Users/apple/Library/Application Support/typora-user-images/image-20230711153004647.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oJOSZvIw-1689733288795)(/Users/apple/Library/Application Support/typora-user-images/image-20230711153033040.png)]

所以说区别到底是什么呢

从两者的架构图上看，虚拟机是在硬件级别进行虚拟化，模拟硬件搭建操作系统，而Docker 是在操作系统的层面虚拟化，复用操作系统，运行 Docker 容器。
Docker 的速度很快，秒级，而虚拟机的速度通常要按分钟计算。
Docker 所用的资源更少，性能更高。同样一个物理机器，Docker 运行的镜像数量远多于虚拟机的数量。
虚拟机实现了操作系统之间的隔离，Docker 是进程之间的隔离，虚拟机隔离级别更高、安全性方面也更强。
虚拟机和 Docker 各有优势，不存在谁替代掉谁的问题，很多企业都采用物理机上做虚拟机，虚拟机中跑 Docker 的方式。

特性	容器	虚拟机

启动速度	秒级	分钟级别
磁盘使用	一般为mb	一般为gb
性能	接近原生	弱于
系统支持量	单机支持上千个容器	一般是十几个
隔离性	完全隔离	完全隔离

docker安装

docker官网

https://docs.docker.com/
https://www.docker.com

Docker 安装

1.Docker 要求 CentOS7 系统的内核版本在 3.10 以上，查看本页面的前提条件来验证你的 CenTOS 版本是否支持 Docker1、通过 uname -r 命令查看你当前的内核版本

uname -r

2.使用 root 权限登录 Centos。确保 yum 包更新到最新。

yum -y update

3.卸载旧版本(如果安装过旧版本的话)

yum remove docker docker-common docker-selinux docker-engine

4.安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的

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

5、设置yum源

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

6、可以查看所有仓库中所有docker版本，并选择特定版本安装

yum list docker-ce --showduplicates | sort -r

7、安装docker

sudo yum install -y docker-ce   #由于repo中默认只开启stable仓库，故这里安装的是最新稳定版18.03.1

8、启动并加入开机启动

systemctl start docker
systemctl enable docker

9、验证安装是否成功(有client和service两部分表示docker安装启动都成功了)

docker version
#或者
systmctl status docker   #查看运行状态

Docker加载镜像配置

https://hub.docker.com/search?q=redis&type=image —在国外访问可能比较慢国内从 DockerHub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务，例如：

科大镜像：https://docker.mirrors.ustc.edu.cn/

网易：https://hub-mirror.c.163.com/

阿里云：https://<你的ID>.mirror.aliyuncs.com

七牛云加速器：https://reg-mirror.qiniu.com

当配置某一个加速器地址之后，若发现拉取不到镜像，请切换到另一个加速器地址。国内各大云服务商均提供了 Docker 镜像加速服务，建议根据运行 Docker 的云平台选择对应的镜像加速服务。

阿里云加速镜像配置

我的加速镜像：https://w83b50de.mirror.aliyuncs.com

阿里云镜像获取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

登陆后，左侧菜单选中镜像加速器就可以看到你的专属地址了：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2IApF0oy-1689733288796)(/Users/apple/Library/Application Support/typora-user-images/image-20230711172809175.png)]

直接运行下面的命令

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://w83b50de.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YLVsJrcx-1689733288797)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps2.jpg)]

如何查看加速镜像安装成功

输入：docker info

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C8Ggr0Ts-1689733288798)(/Users/apple/Library/Application Support/typora-user-images/image-20230713094858618.png)]

docker常用命令

docker --help

帮助命令

docker – version

查看版本

docker images

查看本地images 镜像缓存

docker images 查看本地镜像文件

docker rmi -f kibana:5.6.9 —删除镜像文件

字段：

REPOSITORY 存储库名称

Tag 镜像的标签不写版本号码默认下载最新latest镜像

IMAGE ID 镜像id

CREATED 创建时间

SIZE 大小

docker images -a

docker images -q —只显示镜像的id

docker images --digests —显示镜像的摘要信息

docker images --no-trunc —显示完整镜像信息

docker rmi tomcat（镜像文件名称）

docker search

docker search mysql

https://hub.docker.com/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WmzKktR5-1689733288799)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps4.jpg)]

docker search -s 30 mysql 列出点赞数超过30以上。

latest 表示为最新的镜像文件 mysql8.0版本

docker pull

latest -----tag 最新版本的镜像文件

docker pull nginx:latest --默认的情况下下载最新版本的镜像可以通过

https://hub.docker.com/_/nginx?tab=tags&page=1&ordering=last_updated

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pmEmjJio-1689733288800)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps5.jpg)]

查看容器信息

docker ps 获取到容器id

docker inspect 1e07cc5cc78d

运行容器

docker run

docker run -i（保持容器一直运行）-t（给容器一个伪终端）-d(后台运行，不直接进入容器) --name=tomcat9.2（给启动容器起名字）-p 8080:8080(宿主:docker容器)tomcat:9.2(启动的容器) 【参数】(加入容器初始化命令)

#通过 -it 启动的容器有两个特点一创建就进入容器 exit退出容器容器就会停止运行 —交互式容器

#通过 -id 创建的容器 docker exec -it tomcat9.2（–name起的名称）进入容器 exit退出容器容器不会停止运行 —守护式容器

docker ps 查看正在运行的容器

docker ps -a 查看运行和已经运行关闭大的容器

docker stop tomcat8 关闭容器

docker start tomcat8 启动容器

docker rm tomcat8 删除容器

docker inspect tomcat8 查看容器信息

docker exec 参数进入容器

docker run 运行原理

docker run mayikt

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RFZCFXMe-1689733288801)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps6.jpg)]

简单描述：首先会先从本地获取获取mayikt镜像文件，如果本地没有该镜像文件则会去

阿里云仓库查找该镜像文件，如果阿里云仓库也没有该镜像文件，则会报错找不到

镜像文件。

获取到镜像文件之后直接运行。

详细描述：

1.docker在本机缓存中 mayikt镜像文件，如果本地存在该镜像文件

，则以该镜像文件作为模板在容器中运行。

2.如果本地缓存中，没有mayikt镜像文件则会从dockerhub 或者加速镜像中

查找，如果查找不到的话，则返回错误找不到该镜像。

\1. 如果能够查找到该镜像，则以该镜像作为模板运行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7kRAHg6K-1689733288802)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps7.jpg)]

每个容器都有自己独立的网络 ip信息运行成功就是一个轻量级linux操作系统

启动容器

docker start 容器id

停止容器

docker stop 容器id

删除容器

docker rm 容器id

进入容器中

# 首先使用下面的命令，查看容器ID（CONTAINER ID）：

docker ps -a

# 然后用下面的命令进入容器，就可以使用bash命令浏览容器里的文件：

docker exec -it [CONTAINER ID] bash

# 有的镜像没有bash命令，可以用对应的shell，比如sh

docker exec -it [CONTAINER ID] sh

在运行容器的过程中需要指定名字，不然会创建出多个容器来

–name: 指定容器名称

-p:指定容器端d99c06aFGAIA2ZsG

-d:指定容器后台运行
docker run --name mavikt-tomcattomcat
-p 8081:8080

docker run --name mavikt-tomcatltomcat
8081 (容器外部或者 linux 虚拟机访问的端口号宿主机)8080 容器内部的端口号
-p 8081:8080

docker run --name mayikt-tomcattomcat:8
-d 后台启动
前台启动与后台启动的区别
前台启动会打印启动日志信息
后台启动不会打印启动日志信息

Docker Commit

主要作用：根据当前容器制作为镜像文件

流程：

从docker hub中下载一个tomcat8镜像文件；
运行tomcat8镜像文件在tomcatwebapps 目录中新增 mayikt文件夹 index.html
将当前容器内容根据模板制作为镜像文件

docker commit提交容器副本使之成为一个新的镜像

命令：docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

安装一个tomcat8

1.docker run -p 8081:8080 tomcat:8

docker exec -it 3a06b4c779a8 bash
cd webapps
mkdir mayikt
touch index.html
echo “mayikt” >>index.html

docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

1.根据当前容器作为模板制作为镜像文件

docker commit -m=“mayikt tomcat” -a=“mayikt” 3a06b4c779a8 mayikt-tomcat:1.0

2.在以当前自己制作的镜像文件运行

docker run -p 8088:8080 mayikt-tomcat:1.0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NTLrCh8o-1689733288803)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps1.jpg)]

Docker数据卷

基本的概念

数据卷就是宿主机上的一个文件或目录

当容器目录和数据卷（宿主机）目录绑定，双方修改会立即同步操作

一个数据卷可以被多个容器同时挂载

数据卷作用：容器数据的持久化外部机器和容器间接通信容器之间数据交换

使用 -v命令。

数据卷添加的方式

容器内与宿主机实现数据的共享

数据卷–添加两种方式

\1. 直接命令形式添加 docker run -it -v 宿主机绝对路径目录:容器内目录镜像文件名称

\2. Dockerfile方式添加

安装Nginx实现负载均衡

挂载nginx html文件

https://hub.docker.com/search?q=nginx&type=image

\1. 创建挂载目录

mkdir -p /data/nginx/{conf,conf.d,html,logs}

\2. 启动docker容器

docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html nginx

-v /data/nginx/html 虚拟机目录 --挂载容器目录 /usr/share/nginx/html

上传一个 html 放入到 /data/nginx/html

docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html nginx

-v /data/nginx/html: linux虚拟机目录

/usr/share/nginx/html 容器中html目录

nginx .conf文件和日志文件

docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html \

-v /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \

-v /data/nginx/logs:/var/log/nginx nginx

\反斜杠表示换行

/usr/share/nginx/html

/usr/share/nginx/conf

/usr/share/nginx/log

数据卷volumes-from

容器间传递共享数据volumes-from

Docker运行底层原理

\1. 首先启动docker systemctl start docker

\2. Docker是一个CS架构的系统，docker守护进程运行在主机上，让后通过socket连接

从客户端访问，守护进程从客户端接收命令管理运行在主机上的容器。

ps aux | grep ‘docker’

网站“bs”CS

启动容器报错了如何解决

先改为前台启动如果没有问题的情况下，在修改为后台启动。

DockerFile 解析

一个镜像文件到底是如何创建？

\1. dockerfile 描述出镜像文件需要的一些依赖配置和环境变量执行命令

\2. 将我们dockerfile 文件打包成一个镜像文件

\3. 直接使用我们的容器运行到该镜像文件。

步骤

\1. 需要手动编写一个dockerfile文件

\2. 将该dockerfile docker build 自定义成一个镜像文件

\3. docker run 运行容器

Centos镜像文件

docker run -it centos

DockerFile编写规范

A.#描述注释

B.指令必须要大写，后面至少需要带至少一个参数;

C.指令是按照从上到下，顺序执行；

DockerFile指令

\1. FROM 指定父镜像: 基于哪个镜像image构建指定基础镜像，必须为第一个命令

\2. MAINTAINER :维护者

\3. RUN: 容器创建的时候执行一段命令构建镜像时执行的命令

\4. ADD: 将本地文件添加到容器中，tar类型文件会自动解压(网络压缩资源不会被解压)，可以访问网络资源，类似wget

\5. COPY:功能类似ADD，但是是不会自动解压文件，也不能访问网络资源

\6. CMD:构建容器后调用，也就是在容器启动时才进行调用。 .sh执行文件

\7. ENV: 设置环境变量

\8. EXPOSE: 指定于外界交互的端口

\9. VOLUME 用于指定持久化目录

\10. WORKDIR 设置进入容器时的路径默认访问的目录

Tomcat-----jdk环境

Tomcat docker File：

https://github.com/docker-library/tomcat/blob/385e8403a38fab7097d4c3fed2484caba7dfd099/8.5/jdk8/openjdk-slim-buster/Dockerfile

https://github.com/docker-library/redis/blob/231905d0841f52ee4f3a5b8b42d62cd6d14a1a93/6.2/Dock

进入tomcat 容器----/data

redis容器/data

DockerFile案例

Base镜像(scratch) docker hub中的镜像都是通过base镜像中安装和配置需要的软件构建的。

构建自己centos镜像

docker run -it centos

\1. 需求定制修改centos根目录；

\2. 实现支持vim插件；

yum -y install vim

\1. 需要自己制作一个dockerfile文件

\2. 继承docker hub中的centos

\3. 在docker hubcentos 上加入以下两个功能

A.进入容器中默认访问目录/usr

B.实现支持vim插件

需要将该dockerfile文件打包成一个镜像文件交给我们容器执行

https://github.com/CentOS/sig-cloud-instance-images/blob/b2d195220e1c5b181427c3172829c23ab9cd27eb/docker/Dockerfile

定制CentOS镜像

#继承centos
FROM  centos
#作者
MAINTAINER luo yue
#环境变量
ENV  MYPATH /usr
#进入容器后默认访问的目录
WORKDIR $MYPATH
#安装vim
RUN yum -y install vim
#端口
EXPOSE 80
#启动后自动进入到容器
CMD /bin/bash

创建一个dockerfile文件夹，将上述的内容放入其中

Dockerfile→使用docker 将该Dockerfile实现打包成镜像文件→容器运行该镜像文件。

docker build—将该Dockerfile实现打包成镜像文件

将该dockerfile文件上传到linux服务器中

使用

docker build -f Dockerfile -t mycs:1 .

Dockerfile ------配置文件

mycs----打包镜像文件名称

1 tag 版本号码

docker run -it mycs:1

将springboot项目打包部署

\1. 基于docker原生方式部署我们的springboot项目

Dockerfile

2.dockercompose----- 容器编排技术

springboot项目----变成镜像文件—容器运行

\1. 将我们springboot项目—打成一个jar包

2.定义dockerfile文件-----描述出springboot项目配置依赖和环境变量

JDK

注意：springboot内置嵌入我们的tomcat服务器所以不需要额外的tomcat容器来

运行。

原生方式运行我们的jar包

Java- jar指令

\2. 需要先将我们外部jar，拷贝到容器中

\3. 容器运行成功执行java -jar

2.将该dockerfile文件打包成镜像文件-

\1. 将springboot项目打包；

\2. 制作dockerfile文件；

A. 继承我们的jdk环境

B. 将我们本地的jar包拷贝到容器中

C. Java -jar

\3. 将dockerfile文件打包成镜像文件；

\4. 运行该镜像文件即可；

将springboot项目打包

mvn clean package

制作dockerfile文件

# 基础镜像使用java FROM java:8 # 作者 MAINTAINER www.mayikt.com # VOLUME 指定了临时文件目录为/tmp*。** # 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp** *VOLUME /tmp # *将jar包添加到容器中并更名为mayikt.jar ADD mayikt-thymeleaf-1.0-SNAPSHOT.jar mayikt.jar # 运行jar包 *RUN bash -c ‘touch /mayikt.jar’ ENTRYPOINT [“java”,“-Djava.security.egd=file:/dev/./urandom”,“-jar”,“/mayikt.jar”] *#暴露8080端口 *EXPOSE 8080

打包成镜像文件

docker build -f Dockerfile -t mayikt-member:1 .

启动容器

docker run -p 8070:8080 mayikt-member:1

访问测试

Docker Compose

Sitpreprd环境

为什么需要使用Docker Compose

Docker Compose 容器编排技术

容器编排技术

1.现在我们有一个springboot项目，需要依赖Redis、mysql5.7、nginx。

如果使用docker原生部署的话，则需要安装Redis、mysql5、nginx容器，在才可以启动我们springboot项目，这样的话部署项目的流程非常复杂，所以需要引入我们的

Docker compose实现容器编排技术。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1j1GnWqu-1689733288804)(/Users/apple/Library/Application Support/typora-user-images/image-20230717164556805.png)]

基本的概念

Docker-Compose项目是Docker官方的开源项目，负责实现对Docker容器集群的快速编排。

Docker-Compose将所管理的容器分为三层，分别是工程（project），服务（service）以及容器（container）。

开发一个springboot项目—大工程

\1. 依赖mysql

\2. 依赖redis

\3. 依赖zk等。

需要在docker-compose.yml 配置项目工程依赖环境配置

Docker-Compose运行目录下的所有文件（docker-compose.yml，extends文件或环境变量文件等）组成一个工程，若无特殊指定工程名即为当前目录名。一个工程当中可包含多个服务，每个服务中定义了容器运行的镜像，参数，依赖。一个服务当中可包括多个容器实例，Docker-Compose并没有解决负载均衡的问题，因此需要借助其它工具实现服务发现及负载均衡。

Docker-Compose的工程配置文件默认为docker-compose.yml，可通过环境变量COMPOSE_FILE或-f参数自定义配置文件，其定义了多个有依赖关系的服务及每个服务运行的容器。

Compose 中有两个重要的概念：

服务 (service) ：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。

项目 (project) ：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

一个项目可以由多个服务（容器）关联而成，Compose 面向项目进行管理，通过子命令对项目中的一组容器进行便捷地生命周期管理。

Compose 项目由 Python 编写，实现上调用了 Docker 服务提供的 API 来对容器进行管理。因此，只要所操作的平台支持 Docker API，就可以在其上利用 Compose 来进行编排管理。

Docker-Compose分成三层

1.项目层 springboot项目依赖于我们的mysql redis、nginx等一个项目是由多个容器组成的。

2.服务层运行一个镜像的实例 —

Compose环境安装（离线安装)

\1. 访问docker compose github 官网

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cbkd4gkA-1689733288805)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps2.jpg)]

2. docker-compose-Linux-x86_64 上传到服务器中，然后执行如下命令将其移动到/usr/local/bin/目录中并且更名为docker-compose

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

3. 执行如下命令：添加可执行的权限

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

4. 验证docker-compose

docker-compose -v

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CN8yZFNL-1689733288806)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps3.jpg)]

Compose常用命令

docker-compose -h              # 查看帮助

docker-compose up              # 创建并运行所有容器

docker-compose up -d             # 创建并后台运行所有容器

docker-compose -f docker-compose.yml up -d  # 指定模板

docker-compose down             # 停止并删除容器、网络、卷、镜像。

 docker-compose logs    # 查看容器输出日志

docker-compose pull    # 拉取依赖镜像

dokcer-compose config   # 检查配置

dokcer-compose config -q  # 检查配置，有问题才有输出

 docker-compose restart  # 重启服务

docker-compose start   # 启动服务

docker-compose stop    # 停止服务

Compose入门案例

流程:

1. 需要定义一个docker-compose.yml文件----工程

2. 需要在docker-compose文件配置依赖服务

3. docker-compose up 执行该文件

version: '3.0' 
services: 
 tomcat: #服务名称
  container: mytomcat #指定容器名称能够实现容器的复用
  image: tomcat:8  #镜像文件名称  
  ports:
   -8080:8080

Compose模板文件

version: '3.0'
services:
  tomcat80: ##服务名称
    #container_name: tomcat8080 指定容器名称
    image: tomcat:8 #镜像文件名称 run images
    ports:  ###端口号的映射 -p
    - 8080:8080
    volumes: ## 数据源 宿主机与容器数据共享  -v
      - /usr/tomcat/webapps:/usr/local/tomcat/webapps
    networks:  ###定义网络的桥
      - mayikt

  tomcat81: ##服务名称
    #container_name: tomcat8080 指定容器名称
    image: tomcat:8 #镜像文件名称
    ports:  ###端口号的映射
      - 8081:8080
    volumes: ## 数据源 宿主机与容器数据共享
      - /usr/tomcat/webapps:/usr/local/tomcat/webapps
    networks:
      - mayikt
networks:  ## 定义服务的桥
  mayikt:

Compose常用命令

docker-compose ps  #列出项目中所有的容器

docker-compose stop #停止docker-compose

docker-compose logs #查看容器中日志信息

docker-compose pull #拉取服务依赖的镜像

Compose常用配置

Image 镜像名称；

Build 根据docker file 打包 成镜像；

Context 指定docker file文件位置；

Commond 使用command可以覆盖容器启动后默认执行的命令；

Container_name 容器名称；

depends_on 指定依赖那个服务；

Ports 映射的端口号；

extra_hosts 会在/etc/hosts文件中添加一些记录；

Volumes 持久化目录；

volumes_from 从另外一个容器挂在数据卷；

Dns 设置dns

Docker-compose构建同一个局域网

在同一个局域网内容器之间是可以相互访问的

version: '3.0'
services:
  tomcat80: ##服务名称
    #container_name: tomcat8080 指定容器名称
    image: tomcat:8 #镜像文件名称 run images
    ports:  ###端口号的映射 -p
    - 8080:8080
    volumes: ## 数据源 宿主机与容器数据共享  -v
      - /usr/tomcat/webapps:/usr/local/tomcat/webapps
    networks:  ###定义网络的桥
      - mayikt

  tomcat81: ##服务名称
    #container_name: tomcat8080 指定容器名称
    image: tomcat:8 #镜像文件名称
    ports:  ###端口号的映射
      - 8081:8080
    volumes: ## 数据源 宿主机与容器数据共享
      - /usr/tomcat/webapps:/usr/local/tomcat/webapps
    networks:
      - mayikt
networks:  ## 定义服务的桥
  mayikt:

每一个容器中都要配置

 networks:  ###定义网络的桥
      - mayikt

然后在最后面配置

networks:  ## 定义服务的桥
  mayikt:

Compose部署springboot项目

定义Compose文件

version: “3.0” services: mysql: *# mysql服务 * image: mysql:5.7 command: --default-authentication-plugin=mysql_native_password *#解决外部无法访问 * ports: - “3306:3306” *#容器端口映射到宿主机的端口 * environment: MYSQL_ROOT_PASSWORD: ‘root’ MYSQL_ALLOW_EMPTY_PASSWORD: ‘no’ MYSQL_DATABASE: ‘mayikt’ MYSQL_USER: ‘mayikt’ MYSQL_PASSWORD: ‘mayikt’ networks: - mayikt_web mayikt-web: *#自己单独的springboot项目 * hostname: mayikt build: ./ *#需要构建的Dockerfile文件 * ports: - “38000:8080” *#容器端口映射到宿主机的端口 * depends_on: #web服务依赖mysql服务，要等mysql服务先启动 * - mysql networks: - mayikt_web networks: ## 定义服务的桥 * mayikt_web:

Spring项目配置

spring: profiles: active: prd datasource: url: jdbc:mysql://mysql:3306/mayikt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC username: root password: root driver-class-name: com.mysql.jdbc.Driver server: *###端口号 * port: 8080 servlet: *##设置springboot项目访问路径 * context-path: /mayikt

演示效果

http://192.168.163.129:38000/mayikt/insertUser?userName=mayikt&userAge=22

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0bUbf4xZ-1689733288807)(file:private/var/folders/_7/5jf9xd2j53l3cllzjffr08vr0000gn/T/com.kingsoft.wpsoffice.mac/wps-apple/ksohtml//wps7.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NWuX2bdy-1689733288808)(/Users/apple/Library/Application Support/typora-user-images/image-20230717162959076.png)]

Docker可视化工具使用

Portainer

Portainer是一款Docker可视化管理工具，允许我们在网页中方便的查看和管理Docker容器。

要使用Portainer很简单，运行下面两条命令即可。这些命令会创建一个Portainer专用的卷，然后在8000和9000端口创建容器并运行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tqIkA9D0-1689733288809)(/Users/apple/Library/Application Support/typora-user-images/image-20230719095351977.png)]

1.拉取镜像

docker search portainer
docker pull portainer/portainer

2.运行

docker run -d -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer

-v /var/run/docker.sock:/var/run/docker.sock是保证能够获取到本地镜像

落月爱学习

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
docker学习

在一台物理机器上，利用虚拟化技术，虚拟出来多个操作系统，每个操作系统之间是隔离的。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hK2rrNw1-1689733288793)(/Users/apple/Library/Application Support/typora-user-images/image-20230711152717691.png)]docker是开源性的应用容器引擎最下面两层，概念同上。往上，可以看做 Docker 容器的管理器。
复制链接

扫一扫