Docker快速入门

docker的安装:

移除就旧版本的docker:

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

配置docker的 yum 源:

# 配置docker yum源。
sudo yum install -y yum-utils
sudo yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

安装最新的docker:

sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

启动& 开机启动docker； enable + start 二合一

systemctl enable docker --now

配置加速镜像:

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
    "registry-mirrors":[
    "http://hub-mirror.c.163.com",
    "https://docker.mirrors.ustc.edu.cn",
    "https://cr.console.aliyun.com",
    "https://dockerproxy.com",
    "https://mirror.baidubce.com",
    "https://mirror.ccs.tencentyun.com",
    "https://hub.rat.dev",
    "https://docker.m.daocloud.io",
    "https://do.nark.eu.org",
    "https://dockerpull.com",
    "https://dockerproxy.cn",
    "https://docker.awsl9527.cn"
  ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

docker的基本命令:

#查看运行中的容器
docker ps
#查看所有容器
docker ps -a
#搜索镜像
docker search nginx
#下载镜像
docker pull nginx
#下载指定版本镜像
docker pull nginx:1.26.0
#查看所有镜像
docker images
#删除指定id的镜像
docker rmi e784f4560448


#运行一个新容器
docker run nginx
#停止容器
docker stop keen_blackwell
#启动容器
docker start 标号/名字
#重启容器
docker restart 标号/名字
#查看容器资源占用情况
docker stats 标号/名字
#查看容器日志
docker logs 标号/名字
#删除指定容器
docker rm 标号/名字
#强制删除指定容器
docker rm -f 标号/名字
# 后台启动容器
docker run -d --name mynginx nginx
# 后台启动并暴露端口
docker run -d --name mynginx -p 80:80 nginx

# 进入容器内部
docker exec -it mynginx /bin/bash

# 提交容器变化打成一个新的镜像
docker commit -m "update index.html" mynginx mynginx:v1.0
# 保存镜像为指定文件
docker save -o mynginx.tar mynginx:v1.0
# 删除多个镜像
docker rmi bde7d154a67f 94543a6c1aef e784f4560448
# 加载镜像
docker load -i mynginx.tar 


# 登录 docker hub
docker login
# 重新给镜像打标签
docker tag mynginx:v1.0 leifengyang/mynginx:v1.0
# 推送镜像
docker push leifengyang/mynginx:v1.0



//删除所有的镜像:
docker rm -f $(docker ps -aq)

//删除所有images
docker rmi $(docker images -q)

保存镜像+分享镜像:

提交镜像:

docker commit 镜像名称/id  自定名称

保存镜像:

docker -o 名称.tar imagesName

传输给目标机器后

docker load -i 名称.tar

记住需要目录挂载,请先创建指定的挂载目录

镜像文件存储:

两种方式，注意区分：

• 目录挂载： -v /app/nghtml:/usr/share/nginx/html
• 卷映射：-v ngconf:/etc/nginx

docker run -d -p 99:80 \
-v /app/nghtml:/usr/share/nginx/html \
-v ngconf:/etc/nginx \
--name app03 \
nginx

在 Docker 中，目录挂载（Volume Mounting）是一种将主机文件系统中的目录或文件与 Docker 容器中的目录或文件进行连接的机制。这使得容器能够访问主机上的数据，或者将数据持久化存储，即使容器被删除后数据仍然存在。

就是将docker启动容器镜像时,是以目录挂载的目录文件为配置启动,然后再同步给镜像的配置,两个文件同时加载,改变

Docker 的卷映射（Volume Mapping）是一种将 Docker 容器中的目录与主机文件系统或 Docker 管理的卷（Volumes）进行连接的机制。这种映射允许容器访问和持久化数据，确保数据在容器生命周期之外得以保存。

区别:

卷映射（Volumes）和目录挂载（Bind Mounts）是 Docker 中两种不同的机制，用于将容器中的数据与主机文件系统或 Docker 管理的存储空间连接起来。以下是它们的主要区别：

1. 存储位置

• 卷映射（Volumes） ：

• • 数据存储在 Docker 的管理下，通常在 Docker 的内部存储区域。
  • 卷的生命周期与容器分离，即使容器被删除，数据仍然保留。

• 目录挂载（Bind Mounts） ：

• • 直接将主机上的特定文件或目录挂载到容器中。
  • 数据存储在主机的文件系统中，与主机的路径直接相关。

2. 数据共享

• 卷映射：

• • 支持多个容器共享同一个卷，适合数据共享和持久化需求。

• 目录挂载：

• • 也支持多个容器访问同一个挂载点，但依赖于主机文件系统的路径。

3. 管理方式

• 卷映射：

• • 通过 Docker CLI 命令（如 docker volume create 和 docker volume ls）来管理。
  • 管理较为简单，Docker 负责处理卷的生命周期。

• 目录挂载：

• • 直接使用主机的文件系统路径，管理和配置更依赖于主机的文件系统结构。

4. 安全性和隔离性

• 卷映射：

• • 提供更好的隔离性，Docker 控制数据访问，降低了直接对主机文件系统的依赖。

• 目录挂载：

• • 直接访问主机的文件系统，可能带来安全风险，容器可能会有对主机文件系统的全面访问权限。

5. 性能

• 卷映射：

• • 通常性能更佳，因为它们由 Docker 直接管理，优化了存储。

• 目录挂载：

• • 性能可能受到主机文件系统的影响，尤其是在大量读写操作时。

总结

• 卷映射适合需要持久化和共享的容器数据，提供更高的管理便利性和安全性。
• 目录挂载适合需要直接访问主机文件的场景，尤其在开发和调试阶段非常有用。

根据具体需求选择合适的方式，可以帮助实现更高效的容器化应用管理。

就是当目录挂载时外部配置文件为空的时候,镜像启动会发现没有配置文件,导致启动失败,而使用卷映射时候,是先以镜像自己得 配置文件为基础启动,然后将对应的文件映射给对应的主机文件

有时候启动失败是因为无法访问(无权访问)到本地文件,这时候需要将本地文件的权限修改

chmod [选项] 权限 文件名
权限直接777

网路:

当容器之间需要互相访问的时候使用curl 去访问的话还要先去连接镜像外部的网络,外部网络再去获取另一个镜像的许可,

而我们可以自己先在容器内部创建一个网络用于内部的连接,这样就可以绕过外部网络部了

docker network create mynet

redis主从集群:

#自定义网络
docker network create mynet
#主节点
docker run -d -p 6379:6379 \
-v /app/rd1:/bitnami/redis/data \
-e REDIS_REPLICATION_MODE=master \
-e REDIS_PASSWORD=123456 \
--network mynet --name redis01 \
bitnami/redis

#从节点
docker run -d -p 6380:6379 \
-v /app/rd2:/bitnami/redis/data \
-e REDIS_REPLICATION_MODE=slave \
-e REDIS_MASTER_HOST=redis01 \
-e REDIS_MASTER_PORT_NUMBER=6379 \
-e REDIS_MASTER_PASSWORD=123456 \
-e REDIS_PASSWORD=123456 \
--network mynet --name redis02 \
bitnami/redis

-e 代表设置环境变量

启动mysql:

docker run -d -p 3306:3306 \
-v /app/myconf:/etc/mysql/conf.d \
-v /app/mydata:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:8.0.37-debian

最后一行指定版本就行

docker compose(重点中的重点):

使用 Docker Compose，用户可以通过 YAML 文件来配置应用程序的服务、网络和卷，从而简化了多容器应用的管理。

主要特点：

1. 定义服务：用户可以在 docker-compose.yml 文件中定义多个服务（容器），并为每个服务指定镜像、构建选项、环境变量、端口映射等。
2. 一键启动：通过简单的命令（如 docker-compose up），用户可以启动所有定义的服务，并且它们会自动处理依赖关系。
3. 网络和数据管理：Docker Compose 可以轻松地管理容器之间的网络连接和数据持久化（使用卷）。
4. 多环境支持：用户可以使用不同的 Compose 文件为不同的环境（如开发、测试、生产）配置服务。

1. 命令式安装

#创建网络
docker network create blog

#启动mysql
docker run -d -p 3306:3306 \
-e MYSQL_ROOT_PASSWORD=123456 \
-e MYSQL_DATABASE=wordpress \
-v mysql-data:/var/lib/mysql \
-v /app/myconf:/etc/mysql/conf.d \
--restart always --name mysql \
--network blog \
mysql:8.0

#启动wordpress
docker run -d -p 8080:80 \
-e WORDPRESS_DB_HOST=mysql \
-e WORDPRESS_DB_USER=root \
-e WORDPRESS_DB_PASSWORD=123456 \
-e WORDPRESS_DB_NAME=wordpress \
-v wordpress:/var/www/html \
--restart always --name wordpress-app \
--network blog \
wordpress:latest

2. compose.yaml

name: myblog
services:
  mysql:
    container_name: mysql
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=wordpress
    volumes:
      - mysql-data:/var/lib/mysql
      - /app/myconf:/etc/mysql/conf.d
    restart: always
    networks:
      - blog

  wordpress:
    image: wordpress
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: root
      WORDPRESS_DB_PASSWORD: 123456
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress:/var/www/html
    restart: always
    networks:
      - blog
    depends_on:
      - mysql

volumes:
  mysql-data:
  wordpress:

networks:
  blog:

使用compos.yaml方式去安装启动的话方便更安全

3. 特性

• 增量更新

• • 修改 Docker Compose 文件。重新启动应用。只会触发修改项的重新启动。

• 数据不删

• • 默认就算down了容器，所有挂载的卷不会被移除。比较安全

3.1. 1. 基本结构

一个典型的 docker-compose.yml 文件的基本结构如下：

yamlCopy Codeversion: '3.8'  # Compose 文件的版本
services:       # 定义服务
  service_name: # 服务名称
    image: image_name:tag  # 指定使用的镜像
    build:         # 构建服务的选项
      context: ./path  # 上下文路径
      dockerfile: Dockerfile  # Dockerfile 的名称
    ports:         # 映射端口
      - "8080:80"  # 主机端口:容器端口
    environment:   # 设置环境变量
      - ENV_VAR=value
    volumes:       # 挂载卷
      - ./data:/data  # 主机路径:容器路径
    networks:      # 指定网络
      - my_network

networks:        # 定义网络
  my_network:

3.2. 2. 常用指令

• services: 定义一个或多个服务。
• image: 指定容器使用的镜像。
• build: 配置构建服务的方式。
• ports: 映射容器端口到主机端口。
• volumes: 定义卷挂载。
• environment: 设置容器的环境变量。
• networks: 定义服务的网络。

3.3. 3. 示例

以下是一个完整的 Docker Compose 示例：

yamlCopy Codeversion: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example
    volumes:
      - db_data:/var/lib/mysql
    networks:
      - backend

networks:
  frontend:
  backend:

volumes:
  db_data:

3.4. 4. 常用命令

• 启动服务:

bashCopy Codedocker-compose up

• 后台运行服务:

bashCopy Codedocker-compose up -d

• 停止服务:

bashCopy Codedocker-compose down

• 查看服务状态:

bashCopy Codedocker-compose ps

• 构建服务:

bashCopy Codedocker-compose build

3.5. 5. 其他配置选项

• restart: 指定重启策略，例如 always、unless-stopped、on-failure。
• depends_on: 定义服务之间的依赖关系，例如 depends_on: - db。

Docker Compose 使得多容器应用的配置和管理变得更加简单和直观。根据实际需要，可以灵活调整 docker-compose.yml 文件中的配置。

Dockerfile

Dockerfile 是一个文本文件，包含了一系列指令，用于构建 Docker 镜像。通过编写 Dockerfile，你可以定义如何从基础镜像开始，添加文件、安装软件、设置环境变量等，以便创建一个自定义的 Docker 镜像。以下是 Dockerfile 的基本用法和一些示例。

基本指令

1. FROM：指定基础镜像。
2. RUN：在镜像构建时执行命令（如安装软件）。
3. COPY：将文件从主机复制到镜像中。
4. ADD：类似于 COPY，但可以解压缩 tar 文件。
5. CMD：指定容器启动时执行的命令。
6. ENTRYPOINT：为容器指定默认的可执行程序。
7. ENV：设置环境变量。
8. EXPOSE：声明容器监听的端口（不实际开放端口）。
9. VOLUME：创建挂载点以持久化数据。

Dockerfile 示例

以下是一个简单的 Dockerfile 示例，创建一个运行 Node.js 应用的镜像：

dockerfileCopy Code# 使用官方 Node.js 作为基础镜像
FROM node:14

# 设置工作目录
WORKDIR /usr/src/app

# 将 package.json 和 package-lock.json 复制到工作目录
COPY package*.json ./

# 安装依赖
RUN npm install

# 将应用代码复制到工作目录
COPY . .

# 暴露应用运行的端口
EXPOSE 3000

# 启动应用
CMD ["node", "app.js"]

使用 Dockerfile 构建镜像

1. 保存 Dockerfile：将上述内容保存到名为 Dockerfile 的文件中。
2. 构建镜像：在 Dockerfile 所在目录下运行以下命令：

bashCopy Codedocker build -t my-node-app .

这里，-t 选项指定镜像的名称，. 表示当前目录作为上下文。

3. 运行容器：构建完成后，你可以使用以下命令运行容器：

bashCopy Codedocker run -p 3000:3000 my-node-app

这会将主机的 3000 端口映射到容器的 3000 端口。

注意事项

• 分层构建：Dockerfile 的每个指令都会创建一个新的镜像层，因此尽量将常用的指令放在前面，减少不必要的构建时间。
• 缓存机制：Docker 会缓存每一步的结果，只有在 Dockerfile 中的指令或上下文变化时才会重新构建，这样可以加速构建过程。

通过编写和使用 Dockerfile，你可以轻松创建、共享和管理自定义 Docker 镜像，以适应不同的开发和生产环境。

一键安装超多中间件:

注意：

• 将下面文件中 kafka 的 119.45.147.122 改为你自己的服务器IP。
• 所有容器都做了时间同步，这样容器的时间和linux主机的时间就一致了

准备一个 compose.yaml文件，内容如下：

name: devsoft
services:
  redis:
    image: bitnami/redis:latest
    restart: always
    container_name: redis
    environment:
      - REDIS_PASSWORD=123456
    ports:
      - '6379:6379'
    volumes:
      - redis-data:/bitnami/redis/data
      - redis-conf:/opt/bitnami/redis/mounted-etc
      - /etc/localtime:/etc/localtime:ro

  mysql:
    image: mysql:8.0.31
    restart: always
    container_name: mysql
    environment:
      - MYSQL_ROOT_PASSWORD=123456
    ports:
      - '3306:3306'
      - '33060:33060'
    volumes:
      - mysql-conf:/etc/mysql/conf.d
      - mysql-data:/var/lib/mysql
      - /etc/localtime:/etc/localtime:ro

  rabbit:
    image: rabbitmq:3-management
    restart: always
    container_name: rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      - RABBITMQ_DEFAULT_USER=rabbit
      - RABBITMQ_DEFAULT_PASS=rabbit
      - RABBITMQ_DEFAULT_VHOST=dev
    volumes:
      - rabbit-data:/var/lib/rabbitmq
      - rabbit-app:/etc/rabbitmq
      - /etc/localtime:/etc/localtime:ro
  opensearch-node1:
    image: opensearchproject/opensearch:2.13.0
    container_name: opensearch-node1
    environment:
      - cluster.name=opensearch-cluster # Name the cluster
      - node.name=opensearch-node1 # Name the node that will run in this container
      - discovery.seed_hosts=opensearch-node1,opensearch-node2 # Nodes to look for when discovering the cluster
      - cluster.initial_cluster_manager_nodes=opensearch-node1,opensearch-node2 # Nodes eligibile to serve as cluster manager
      - bootstrap.memory_lock=true # Disable JVM heap memory swapping
      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m" # Set min and max JVM heap sizes to at least 50% of system RAM
      - "DISABLE_INSTALL_DEMO_CONFIG=true" # Prevents execution of bundled demo script which installs demo certificates and security configurations to OpenSearch
      - "DISABLE_SECURITY_PLUGIN=true" # Disables Security plugin
    ulimits:
      memlock:
        soft: -1 # Set memlock to unlimited (no soft or hard limit)
        hard: -1
      nofile:
        soft: 65536 # Maximum number of open files for the opensearch user - set to at least 65536
        hard: 65536
    volumes:
      - opensearch-data1:/usr/share/opensearch/data # Creates volume called opensearch-data1 and mounts it to the container
      - /etc/localtime:/etc/localtime:ro
    ports:
      - 9200:9200 # REST API
      - 9600:9600 # Performance Analyzer

  opensearch-node2:
    image: opensearchproject/opensearch:2.13.0
    container_name: opensearch-node2
    environment:
      - cluster.name=opensearch-cluster # Name the cluster
      - node.name=opensearch-node2 # Name the node that will run in this container
      - discovery.seed_hosts=opensearch-node1,opensearch-node2 # Nodes to look for when discovering the cluster
      - cluster.initial_cluster_manager_nodes=opensearch-node1,opensearch-node2 # Nodes eligibile to serve as cluster manager
      - bootstrap.memory_lock=true # Disable JVM heap memory swapping
      - "OPENSEARCH_JAVA_OPTS=-Xms512m -Xmx512m" # Set min and max JVM heap sizes to at least 50% of system RAM
      - "DISABLE_INSTALL_DEMO_CONFIG=true" # Prevents execution of bundled demo script which installs demo certificates and security configurations to OpenSearch
      - "DISABLE_SECURITY_PLUGIN=true" # Disables Security plugin
    ulimits:
      memlock:
        soft: -1 # Set memlock to unlimited (no soft or hard limit)
        hard: -1
      nofile:
        soft: 65536 # Maximum number of open files for the opensearch user - set to at least 65536
        hard: 65536
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - opensearch-data2:/usr/share/opensearch/data # Creates volume called opensearch-data2 and mounts it to the container

  opensearch-dashboards:
    image: opensearchproject/opensearch-dashboards:2.13.0
    container_name: opensearch-dashboards
    ports:
      - 5601:5601 # Map host port 5601 to container port 5601
    expose:
      - "5601" # Expose port 5601 for web access to OpenSearch Dashboards
    environment:
      - 'OPENSEARCH_HOSTS=["http://opensearch-node1:9200","http://opensearch-node2:9200"]'
      - "DISABLE_SECURITY_DASHBOARDS_PLUGIN=true" # disables security dashboards plugin in OpenSearch Dashboards
    volumes:
      - /etc/localtime:/etc/localtime:ro
  zookeeper:
    image: bitnami/zookeeper:3.9
    container_name: zookeeper
    restart: always
    ports:
      - "2181:2181"
    volumes:
      - "zookeeper_data:/bitnami"
      - /etc/localtime:/etc/localtime:ro
    environment:
      - ALLOW_ANONYMOUS_LOGIN=yes

  kafka:
    image: 'bitnami/kafka:3.4'
    container_name: kafka
    restart: always
    hostname: kafka
    ports:
      - '9092:9092'
      - '9094:9094'
    environment:
      - KAFKA_CFG_NODE_ID=0
      - KAFKA_CFG_PROCESS_ROLES=controller,broker
      - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://0.0.0.0:9094
      - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://kafka:9092,EXTERNAL://119.45.147.122:9094
      - KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP=CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT,PLAINTEXT:PLAINTEXT
      - KAFKA_CFG_CONTROLLER_QUORUM_VOTERS=0@kafka:9093
      - KAFKA_CFG_CONTROLLER_LISTENER_NAMES=CONTROLLER
      - ALLOW_PLAINTEXT_LISTENER=yes
      - "KAFKA_HEAP_OPTS=-Xmx512m -Xms512m"
    volumes:
      - kafka-conf:/bitnami/kafka/config
      - kafka-data:/bitnami/kafka/data
      - /etc/localtime:/etc/localtime:ro
  kafka-ui:
    container_name: kafka-ui
    image: provectuslabs/kafka-ui:latest
    restart: always
    ports:
      - 8080:8080
    environment:
      DYNAMIC_CONFIG_ENABLED: true
      KAFKA_CLUSTERS_0_NAME: kafka-dev
      KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:9092
    volumes:
      - kafkaui-app:/etc/kafkaui
      - /etc/localtime:/etc/localtime:ro

  nacos:
    image: nacos/nacos-server:v2.3.1
    container_name: nacos
    ports:
      - 8848:8848
      - 9848:9848
    environment:
      - PREFER_HOST_MODE=hostname
      - MODE=standalone
      - JVM_XMX=512m
      - JVM_XMS=512m
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=nacos-mysql
      - MYSQL_SERVICE_DB_NAME=nacos_devtest
      - MYSQL_SERVICE_PORT=3306
      - MYSQL_SERVICE_USER=nacos
      - MYSQL_SERVICE_PASSWORD=nacos
      - MYSQL_SERVICE_DB_PARAM=characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
      - NACOS_AUTH_IDENTITY_KEY=2222
      - NACOS_AUTH_IDENTITY_VALUE=2xxx
      - NACOS_AUTH_TOKEN=SecretKey012345678901234567890123456789012345678901234567890123456789
      - NACOS_AUTH_ENABLE=true
    volumes:
      - /app/nacos/standalone-logs/:/home/nacos/logs
      - /etc/localtime:/etc/localtime:ro
    depends_on:
      nacos-mysql:
        condition: service_healthy
  nacos-mysql:
    container_name: nacos-mysql
    build:
      context: .
      dockerfile_inline: |
        FROM mysql:8.0.31
        ADD https://raw.githubusercontent.com/alibaba/nacos/2.3.2/distribution/conf/mysql-schema.sql /docker-entrypoint-initdb.d/nacos-mysql.sql
        RUN chown -R mysql:mysql /docker-entrypoint-initdb.d/nacos-mysql.sql
        EXPOSE 3306
        CMD ["mysqld", "--character-set-server=utf8mb4", "--collation-server=utf8mb4_unicode_ci"]
    image: nacos/mysql:8.0.30
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=nacos_devtest
      - MYSQL_USER=nacos
      - MYSQL_PASSWORD=nacos
      - LANG=C.UTF-8
    volumes:
      - nacos-mysqldata:/var/lib/mysql
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "13306:3306"
    healthcheck:
      test: [ "CMD", "mysqladmin" ,"ping", "-h", "localhost" ]
      interval: 5s
      timeout: 10s
      retries: 10
  prometheus:
    image: prom/prometheus:v2.52.0
    container_name: prometheus
    restart: always
    ports:
      - 9090:9090
    volumes:
      - prometheus-data:/prometheus
      - prometheus-conf:/etc/prometheus
      - /etc/localtime:/etc/localtime:ro

  grafana:
    image: grafana/grafana:10.4.2
    container_name: grafana
    restart: always
    ports:
      - 3000:3000
    volumes:
      - grafana-data:/var/lib/grafana
      - /etc/localtime:/etc/localtime:ro

volumes:
  redis-data:
  redis-conf:
  mysql-conf:
  mysql-data:
  rabbit-data:
  rabbit-app:
  opensearch-data1:
  opensearch-data2:
  nacos-mysqldata:
  zookeeper_data:
  kafka-conf:
  kafka-data:
  kafkaui-app:
  prometheus-data:
  prometheus-conf:
  grafana-data:

其中kafka需要修改成自己的ip

按照自己需求截取对应的中间件