在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解

这篇具有很好参考价值的文章主要介绍了在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前言

在了解Docker-Compose之前我们回忆一下之前章节所学,假设我们需要部署一个springboot项目,需要nginxmysqlredis,通常我们启动这些服务run的时候需要设置每个容器的启动参数,指定数据卷,容器命名,指定不同容器的链接参数等等一系列的操作,是不是很繁琐?那么docker-compose就是解决这个问题的。当我们的项目需要哪些镜像,每个镜像怎么配置,要挂载哪些 volume, 等等信息都包含在 docker-compose.yml 里,每次启动这三个容器就只需要docker-composer up命令即可。

什么是Docker-Compose

从过上面的描述,我们大致可以总结为Docker-Compose就是用于定义和运行多容器 Docker 应用程序的工具,负责实现对Docker容器集群的快速编排,解决了容器与容器之间如何管理编排的问题

下载安装和卸载

根据官方文档https://docs.docker.com/compose/install/linux/#install-using-the-repository的安装讲解,可以分为两种安装模式:

使用仓库安装

安装Compose
如果你还没安装过Compose ,博主推荐这种安装方式,后续的升级更方便

yum update
yum install docker-compose-plugin
#验证安装成功
docker compose version

在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解
更新Compose,只需要重新执行安装命令即可

#更新Compose
yum update
yum install docker-compose-plugin

手动安装

安装包会下载到 $HOME/.docker/cli-plugins目录下面的 docker-compose 文件夹内

DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
mkdir -p $DOCKER_CONFIG/cli-plugins
curl -SL https://github.com/docker/compose/releases/download/v2.18.1/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose

对二进制文件应用可执行权限:

chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose

如果选择为所有用户安装Compose则执行:
sudo chmod +x /usr/local/lib/docker/cli-plugins/docker-compose

最后验证安装

docker compose version
Docker Compose version v2.18.1

卸载

注意以下代码块包含了仓库安装的卸载方式,以及手动安装的卸载方式,请注意区分

# 使用仓库安装的卸载方式
sudo yum remove docker-compose-plugin

# 手动安装的卸载方式
rm $DOCKER_CONFIG/cli-plugins/docker-compose

#如果是执行了为所有用户安装的卸载方式
rm /usr/local/lib/docker/cli-plugins/docker-compose

docker compose常用命令

博主目前安装使用的是v2版本,语法为 docker compose ,v1的版本语法为 docker-compose ,大家注意各自版本区分

使用语法

docker compose [OPTIONS] COMMAND

命令列表

指令 说明
docker compose build 构建或重建服务
docker compose up 启动yml定义的所有服务
docker compose stop 停止项目中的所有服务容器
docker compose start 启动项目中的所有服务容器
docker compose restart 重启项目中的所有服务容器
docker compose down 停止并删除容器、网络
docker compose exec 在运行的容器中执行命令
docker compose ps 列出当前项目下的所有容器
docker compose ls 列出正在运行的项目
docker compose images 列出所有已创建的服务容器的镜像信息
docker compose kill 强制停止服务容器
docker compose logs 查看当前项目下所有服务容器的日志输出
docker compose pause 暂停当前项目下一个或多个服务容器
docker compose unpause 恢复当前项目下处于暂停状态的服务
docker compose port 打印某个服务容器的内部端口所映射的公共端口
docker compose pull 拉取当前项目下所有服务依赖的镜像
docker compose push 对于使用build元素构建的服务,我们可以用此命令将其镜像推送到 Docker 镜像仓库
docker compose rm 删除停止的服务容器
docker compose run 为某个服务创建并启动一个全新的容器
docker compose top 显示正在运行的进程
docker compose version 查看Docker Compose 版本信息
docker compose --help 查看帮助信息

更多命令说明,请参考官方文档 https://docs.docker.com/compose/reference/

项目实战

首先我们本次需要快速构建一个SpringBoot项目,并集成Mybatis、Redis、Mysql ,然后构建一个docker-compose.yml进行部署测试;

构建SpringBoot项目

使用IDEA新建项目,项目名docker
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解
选择所需依赖
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解
修改POM文件,引入 druid-spring-boot-starter 最终POM文件如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.toher</groupId>
    <artifactId>docker-test-project</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>docker-test-project</name>
    <description>docker-test-project</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.3.1</version>
        </dependency>
        <!-- 阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>
</project>

修改application.yml文件,配置端口号、数据源、redis

# 端口配置
server:
    port: 9090

# 数据源配置
spring:
    #redis
    redis:
        # 地址
        host: localhost
        # 端口,默认为6379
        port: 6379
        # 数据库索引
        database: 0
        # 密码
        password:
        # 连接超时时间
        timeout: 10s
        lettuce:
            pool:
                # 连接池中的最小空闲连接
                min-idle: 0
                # 连接池中的最大空闲连接
                max-idle: 8
                # 连接池的最大数据库连接数
                max-active: 8
                # #连接池最大阻塞等待时间(使用负值表示没有限制)
                max-wait: -1ms
    #数据源配置
    datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        druid:
            # 主库数据源
            url: jdbc:mysql://localhost:3306/docker_test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
            username: root
            password: 123456

# MyBatis
mybatis:
    # 搜索指定包别名
    typeAliasesPackage: com.toher.**.domain
    # 配置mapper的扫描,找到所有的mapper.xml映射文件
    mapperLocations: classpath*:mapper/**/*Mapper.xml

Mysql 新建docker_test 数据库,导入如下SQL执行,创建数据库student表

DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `id` int NOT NULL AUTO_INCREMENT COMMENT '学生ID',
  `name` varchar(50) NOT NULL COMMENT '学生姓名',
  `gender` varchar(10) NOT NULL COMMENT '学生性别',
  `birthday` date NOT NULL COMMENT '学生生日',
  `address` varchar(100) NOT NULL COMMENT '学生住址',
  `phone` varchar(20) NOT NULL COMMENT '学生联系方式',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='学生信息表';

INSERT INTO `student` (`id`, `name`, `gender`, `birthday`, `address`, `phone`) VALUES (1, '小明', '男', '2023-06-16', '广州', '13724889158');
INSERT INTO `student` (`id`, `name`, `gender`, `birthday`, `address`, `phone`) VALUES (2, '小羊', '女', '2023-06-16', '广州', '13800126000');

项目仅仅为了演示,我们就以最简单的方式构建,创建 DockerTestController Student StudentMapper 在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解
DockerTestController 文件内容

@RestController
public class DockerTestController {

    @Autowired
    private RedisTemplate redisTemplate;
    @Resource
    private StudentMapper studentMapper;

    @GetMapping("/get-student")
    public Student getStudent(){

        Boolean has = redisTemplate.hasKey("student");
        if(has){
            Student student = (Student)redisTemplate.opsForValue().get("student");
            return student;
        }
        Student student = studentMapper.getById(1);
        redisTemplate.opsForValue().set("student",student,5, TimeUnit.MINUTES);
        return student;
    }
}

Student 文件内容

@Data
public class Student implements Serializable {
    private Integer id;
    private String name;
    private String gender;
    private Date birthday;
    private String address;
    private String phone;
}

StudentMapper 文件内容

@Mapper
public interface StudentMapper {
    @Select("select * from student where id = #{id}")
    public Student getById(@Param("id") int id);

    @Insert("insert into student(id, name)values(#{id}, #{name})")
    public int insert(Student user);
}

完成以上步骤,我们运行项目访问 http://localhost:9090/get-student 出现查询出的JSON数据,则SpringBoot 整合Mybatis + Redis + Mysql完成。
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解

编写Dockerfile文件

主要构建两个文件:
一个作为Mysql数据库初始化文件(init-dockerfile)
一个作为Redis配置文件(redis-dockerfile)
一个作为运行SpringBoot项目文件(boot-dockerfile)

init-dockerfile 文件内容

# 基础镜像
FROM mysql
#指定作者
LABEL org.opencontainers.image.authors="micro"
# 执行sql脚本 db目录届时存放存放初始化sql文件
ADD ./db/*.sql /docker-entrypoint-initdb.d/

redis-dockerfile 文件内容

# 基础镜像
FROM redis
#定义环境变量
ENV MYPATH /data/redis
#设置工作目录
WORKDIR $MYPATH
#指定作者
LABEL org.opencontainers.image.authors="micro"
# 挂载目录
VOLUME /data/redis
# 创建目录
RUN mkdir -p /data/redis
# 复制conf文件到路径
COPY /data/redis/redis.conf /data/redis/redis.conf

boot-dockerfile 文件内容

# 基础镜像
FROM java:8
#定义环境变量
ENV MYPATH /data/docker-compose-boot
#设置工作目录
WORKDIR $MYPATH
#指定作者
LABEL org.opencontainers.image.authors="micro"
# 挂载目录
VOLUME /data/docker-compose-boot
# 创建目录
RUN mkdir -p /data/docker-compose-boot
# 复制jar文件到路径 jar文件夹存放我们maven打包好的jar文件
COPY ./jar/*.jar /data/docker-compose-boot/docker-compose-boot.jar
# 启动应用
ENTRYPOINT ["java","-jar","docker-compose-boot.jar"]

编写Docker-Compose.yml文件

version : '3'
services:
  #设置服务
  micro-mysql:
    #指定容器名称
    container_name: micro-mysql
    image: mysql
    build:
      context: .
      #指定执行的dockerfile
      dockerfile: init-dockerfile
    #映射端口
    ports:
      - "3306:3306"
    #挂载数据卷
    volumes:
      - /data/mysql/conf:/etc/mysql/conf.d
      - /data/mysql/data:/var/lib/mysql
      - /data/mysql/logs:/logs
    command: [
          'mysqld',
          '--innodb-buffer-pool-size=80M',
          '--character-set-server=utf8mb4',
          '--collation-server=utf8mb4_unicode_ci',
          '--default-time-zone=+8:00',
          '--lower-case-table-names=1'
        ]
    environment:
      MYSQL_DATABASE: docker_test
      MYSQL_ROOT_PASSWORD: 123456
  micro-redis:
    #指定容器名称
    container_name: micro-redis
    image: redis
    build:
      context: .
      #指定执行的dockerfile
      dockerfile: redis-dockerfile
    #映射端口
    ports:
      - "6379:6379"
    #挂载数据卷
    volumes:
      - /data/redis/redis.conf:/etc/redis/redis.conf
      - /data/redis/data:/data
    command: redis-server /etc/redis/redis.conf
  micro-server:
    container_name: micro-server
    build:
      context: .
      dockerfile: boot-dockerfile
    ports:
      - "9090:9090"
    depends_on:
      - micro-mysql
      - micro-redis
    links:
      - micro-mysql
      - micro-redis

运行测试

Docker-Compose.yml 中指定了 links , springboot项目打包前注意修改ip地址,redis为micro-redis, mysql为micro-mysql,如下图
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解
使用maven打包生产jar文件,最终整体部署前准备目录如下:
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解
将相关文件上传至宿主机,切换至该docker-compose.yml 同级目录运行 docker compose up -d ,访问测试,看到输出的json数据至此我们的部署测试成功!
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解

相关注意事项

  • 注意mysql的版本,我使用的是最新的mysql8版本,如果较低版本注意挂载数据卷 /data/mysql/conf:/etc/mysql/conf.d 的不同
  • 如果之前有存在过的旧挂载卷配置,在运行 docker compose up 前注意清理
  • 目前属于部署测试,如果大家需要容器随宿主机一起开机启动,再每个server 加上 restart: always 配置项
  • 最后注意Docker-Compose.yml 空格问题切记不要 tab键进行空格操作

结语

本章节主要介绍了Docker Compos使用、常用命令介绍,最后以一个SpringBoot整合Mybatis、Redis、Mysql,使用Docker Compos进行部署测试,如果大家需要博主的相关完整源码和配置文件,可以在评论区留下邮箱,博主会给大家邮件发送,最后如果本章节内容对你有用,希望点赞收藏加关注
在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解文章来源地址https://www.toymoban.com/news/detail-500178.html

到了这里,关于在Centos Stream 9上Docker的实操教程(六) - Docker Compose容器编排详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Docker Compose 容器编排

    Docker compose 实现单机容器集群编排管理(使用一个模板文件定义多个应用容器的启动参数和依赖关系,并使用docker compose来根据这个模板文件的配置来启动容器) 通俗来说就是把之前的多条docker run启动容器命令 转换为docker-compose.yml配置文件。 Docker compose 三大概念 项目/工程

    2024年02月15日
    浏览(40)
  • Docker高级:Compose 容器编排

    Compose 是Docker公司推出的一个软件,可以管理多个Docker容器组成一个应用。我们只需要定义一个 YAML 格式的配置文件 docker-compose.yaml 配置好多个容器之间的调用关系 ,最后只需要一个命令,就可以同时控制这些容器进行启动 / 关闭。Compose 允许用户通过一个单独的 docker-compo

    2024年02月06日
    浏览(49)
  • 04-docker compose容器编排

    ​ Compose 是Docker公司推出的一个工具软件,可以管理多个Dokcer容器组成一个应用。你需要定义一个YAML格式的配置文件 docker-compose.yml , 写好多个容器之间的调用关系 。然后,只要一个命令,就能同时启动/关闭这些容器 简单来说,Docker Compose 是Docker官方的开源项目, 负责实

    2024年02月09日
    浏览(42)
  • docker (十)-docker compose容器编排

    在实际工作中,部署一个应用可能需要部署多个容器,一个一个部署非常不方便。docker compose可以一键部署和启动多个容器,它使用yaml文件来编排服务。github和docker hub很多项目都提供了docker-compose.yaml文件,我们可以一键部署项目,非常方便。 这里可以使用 vscode 去学习dock

    2024年02月21日
    浏览(51)
  • Docker 容器编排利器 Docker Compose

    目录 一、Docker Compose 简介 二、Docker Compose 安装 2.1 Mac、Windows 平台默认支持 2.2 Linux 安装(通过包管理) 2.2.1 安装 2.2.2 测试 2.2.3 卸载 2.3 使用PIP 安装与卸载 2.3.1 PIP安装 2.3.2 PIP 卸载 三、基本使用 3.1 术语 3.2 部署Flask 应用 四、Compose 常用命令 4.1 命令对象与格式 4.2 docker-compose

    2024年03月26日
    浏览(55)
  • Docker六 | Docker Compose容器编排

    目录 Docker Compose 基本概念 使用步骤  常用命令  Docker-Compose是Docker官方的开源项目,负责实现对Docker容器集群的快速编排。Compose可以管理多个Docker容器组成一个应用。 需要定义一个YAML格式的配置文件docker-compose.yml,写好多个容器之间的调用关系,然后只需一个命令就能同时

    2024年02月02日
    浏览(48)
  • Docker——compose单机容器集群编排

    Docker-compose是一个基于Docker的容器编排工具。它使用一个YAML文件来定义和配置多个容器的集群。通过使用Docker-compose,我们可以轻松地定义、配置和协同运行多个Docker容器,而无需手动管理它们的启动和通信。 1.为何需要Docker-compose 在现代应用程序开发中,容器化技术已经成

    2024年02月16日
    浏览(45)
  • Docker Compose容器的快速编排

    Docker Compose项目是Docker官方的开源项目,负责实现对Docker容器集群的快速编排(使用一个模板文件定义多个应用容器的启动参数和依赖关系,并使用Docker Compose来根据这个模板文件的配置来启动容器)。 项目/工程 - 包含一个或多个服务 - 包含一个或多个容器 默认使用项目的目

    2024年02月15日
    浏览(47)
  • docker笔记9:Docker-compose容器编排

    目录 1.是什么? 2. 能干嘛? 3.去哪下? 4.安装步骤  ​编辑 5.卸载步骤   6.Compose核心概念  6.1概念 6.2 Compose常用命令   7.Compose编排微服务 7.1改造升级微服务工程docker_boot 7.2不用Compose 7.2.1 单独的mysql容器实例 7.3 swagger测试 7.4上面成功了,有哪些问题? 7.5 使用Compose  7.5.1

    2024年02月09日
    浏览(48)
  • 尚硅谷Docker-笔记12:Compose容器编排

    Compose 是 Docker 公司推出的一个工具软件,可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml,写好多个容器之间的调用关系。然后,只要一个命令,就能同时启动/关闭这些容器。 docker建议我们每一个容器中只运行一个服务,因为docker容

    2024年01月18日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包