最全的Docker-compose应用部署！快收藏！

收集了绝大部分应用使用docker-compose部署的文件，请查收！

让docker-compose变得简简单单！

你需要的都有（都是主流的哈，小众的不一定有），没有的评论区留言，嘿嘿嘿！

有不足的地方请指正，谢谢！

以下是使用docker-compose运行服务的步骤：

1. 创建一个名为docker-compose.yml的文件，并在其中定义服务。例如：

version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"   

2. 在包含docker-compose.yml文件的目录中运行以下命令来启动服务：

docker-compose up -d    

这将以后台模式启动服务。如果一切正常，你将看到类似于以下的输出：

[+] Running 1/1
 ✔ Container nginx  Started                                                                                                  0.3s

3. 停止服务，请在包含docker-compose.yml文件的目录中运行以下命令：

docker-compose down    

1. Web 和应用服务器

1.1 Nginx

Nginx 是一个高性能的开源 Web 服务器和反向代理服务器。

version: '3'
services:
  nginx:
    image: nginx:latest
    container_name: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/conf:/etc/nginx/conf.d
      - ./nginx/html:/usr/share/nginx/html

• version: '3'：指定了Docker Compose文件的版本，'3’是Docker Compose的最新版本。
• services:：此部分定义了要在Docker环境中创建的服务。每个服务表示一个Docker容器。
• nginx:：这是服务的名称，表示要创建一个名为“nginx”的容器。
• image: nginx:latest：指定了要使用的Docker镜像，即nginx:latest，这是Nginx Web服务器的最新版本。
• container_name: nginx：设置了容器的名称，使其在创建时被命名为“nginx”。
• ports:：此部分定义了端口映射。在这里，它将主机的80端口映射到容器的80端口。这意味着当在浏览器中访问主机的80端口时，请求将被路由到容器的80端口，即Nginx服务器监听的端口。
• volumes:：此部分定义了卷（volumes）挂载。在这里，它将主机的./nginx/conf目录挂载到容器的/etc/nginx/conf.d目录。这意味着可以在主机上更新./nginx/conf目录中的Nginx配置文件，并在重启容器后将更改应用到Nginx服务器。此外，还将主机的./nginx/html目录挂载到容器的/usr/share/nginx/html目录，这意味着可以在主机上更新./nginx/html目录中的网页文件，并在重启容器后将更改应用到Nginx服务器的默认网页目录。

在 ./nginx/conf 目录下创建一个名为 default.conf 的 Nginx 配置文件。

server {
    listen 80;
    server_name localhost;

    location / {
        root /usr/share/nginx/html;
        index index.html;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

这个配置文件定义了一个简单的 Nginx 服务器，监听主机的 80 端口，将请求映射到 /usr/share/nginx/html 目录下，并定义了错误页面的处理。

在 ./nginx/html 目录下创建一个名为 index.html 的静态 HTML 文件。可以根据需要编写 HTML 内容。

    
    
    
    


    
Welcome to My Nginx Server
    
This is a simple HTML page served by Nginx.

1.2 Apache

version: '3'
services:
  apache:
    image: httpd:latest
    container_name: apache
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/local/apache2/htdocs

• version: '3'：指定了Docker Compose文件的版本，'3’是Docker Compose的最新版本。
• services:：此部分定义了要在Docker环境中创建的服务。每个服务表示一个Docker容器。
• apache:：这是服务的名称，表示要创建一个名为“apache”的容器。
• image: httpd:latest：指定了要使用的Docker镜像，即httpd:latest，这是Apache HTTP服务器的最新版本。
• container_name: apache：设置了容器的名称，使其在创建时被命名为“apache”。
• ports:：此部分定义了端口映射。在这里，它将主机的80端口映射到容器的80端口。这意味着当在浏览器中访问主机的80端口时，请求将被路由到容器的80端口，即Apache HTTP服务器监听的端口。
• volumes:：此部分定义了卷（volumes）挂载。在这里，它将主机的./html目录挂载到容器的/usr/local/apache2/htdocs目录。这意味着可以在主机上更新./html目录中的内容，并在重启容器后将更改应用到Apache服务器的默认网页目录。

1.3 Tomcat

version: '3'
services:
  tomcat:
    image: tomcat:latest
    container_name: tomcat
    ports:
      - "8080:8080"
    volumes:
      - ./webapps:/usr/local/tomcat/webapps
    environment:
      - CATALINA_OPTS=-Xmx512m

• environment: - CATALINA_OPTS=-Xmx512m：这设置了容器的环境变量。在这种情况下，设置了CATALINA_OPTS环境变量为-Xmx512m。这指定了Java虚拟机（JVM）的最大堆内存大小为512MB。这可以帮助控制Tomcat服务器可使用的最大内存量。

1.4 Lighttpd

version: '3'
services:
  lighttpd:
    image: lighttpd:latest
    container_name: lighttpd
    ports:
      - "80:80"
    volumes:
      - ./lighttpd.conf:/etc/lighttpd/lighttpd.conf
      - ./html:/var/www/html

• “80:80”`: 将主机的80端口映射到容器的80端口，这是常见的Web服务器端口。
• ./lighttpd.conf:/etc/lighttpd/lighttpd.conf`: 将本地的“lighttpd.conf”文件挂载到容器内的“/etc/lighttpd/lighttpd.conf”路径，用于配置Lighttpd服务。
• - ./html:/var/www/html: 将本地的“html”目录挂载到容器内的“/var/www/html”路径，这是Web服务器的默认文档根目录。

2. 数据库

2.1 mysql

version: '3.0'
services:
  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    command:
      --default-authentication-plugin=mysql_native_password
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
      --sql-mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    ports:
      - 3306:3306
    volumes:
      - ./log:/var/log/mysql
      - ./data:/var/lib/mysql
      - ./conf:/etc/mysql

• MYSQL_ROOT_PASSWORD: 123456: 设置环境变量MYSQL_ROOT_PASSWORD为“123456”，表示MySQL的根用户的密码。
• command:: 指定容器启动时要执行的命令。这里是一些MySQL的配置选项，包括默认的认证插件、字符集和排序规则、时间戳的默认值、大小写敏感性和SQL模式等。
• ports:: 指定容器的端口映射。
• - 3306:3306: 将主机的3306端口映射到容器的3306端口，这是MySQL的默认端口。
• volumes:: 指定本地文件系统上的目录和容器内路径之间的挂载关系。
• - ./log:/var/log/mysql: 将本地的“log”目录挂载到容器内的“/var/log/mysql”路径，用于存储MySQL的日志文件。
• - ./data:/var/lib/mysql: 将本地的“data”目录挂载到容器内的“/var/lib/mysql”路径，用于存储MySQL的数据文件。
• - ./conf:/etc/mysql: 将本地的“conf”目录挂载到容器内的“/etc/mysql”路径，用于存储MySQL的配置文件。

2.2 PostgreSQL

version: '3'
services:
  db:
    image: postgres:13.8
    container_name: postgres
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: 123456
      POSTGRES_DB: postgres
    ports:
      - "5433:5432"
    volumes:
      - ./data:/var/lib/postgresql/data

• version: '3': 指定Docker Compose文件的版本为3。
• services:: 指定要部署的服务。
• db:: 定义一个名为“db”的服务，这将是PostgreSQL数据库服务器。
• image: postgres:13.8: 指定使用的PostgreSQL镜像版本为13.8。
• container_name: postgres: 指定容器的名称为“postgres”。
• restart: always: 设置容器退出后自动重启。
• environment:: 指定容器的环境变量。
• POSTGRES_USER: postgres: 设置环境变量POSTGRES_USER为“postgres”，表示PostgreSQL的用户名。
• POSTGRES_PASSWORD: 123456: 设置环境变量POSTGRES_PASSWORD为“123456”，表示PostgreSQL的密码。
• POSTGRES_DB: postgres: 设置环境变量POSTGRES_DB为“postgres”，表示要使用的数据库名。
• ports:: 指定容器的端口映射。
• - "5433:5432": 将主机的5433端口映射到容器的5432端口，这是PostgreSQL的默认端口。
• volumes:: 指定本地文件系统上的目录和容器内路径之间的挂载关系。
• - ./data:/var/lib/postgresql/data: 将本地的“data”目录挂载到容器内的“/var/lib/postgresql/data”路径，这是PostgreSQL默认的数据存储路径。

2.3 Oracle

version: '3.0'
services:
  oracle:
    image: wnameless/oracle-xe-11g-r2
    container_name: oracle
    ports:
      - "1521:1521"
    environment:
      - ORACLE_ALLOW_REMOTE=true

• environment:: 指定容器的环境变量。
• - ORACLE_ALLOW_REMOTE=true: 设置环境变量ORACLE_ALLOW_REMOTE为true，表示允许远程访问Oracle数据库。

2.4 MongoDB

version: '3.0'
services:
  mongodb:
    image: mongo:latest
    container_name: mongodb
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: 123456
    volumes:
      - ./data:/data/db
    ports:
      - "27017:27017"

• image: mongo:latest: 指定使用的MongoDB镜像，这里是最新版本。
• container_name: mongodb: 指定容器的名称为“mongodb”。
• environment:: 指定容器的环境变量。
• MONGO_INITDB_ROOT_USERNAME: root: 设置环境变量MONGO_INITDB_ROOT_USERNAME为"root"，表示MongoDB的根用户名。
• MONGO_INITDB_ROOT_PASSWORD: 123456: 设置环境变量MONGO_INITDB_ROOT_PASSWORD为"123456"，表示MongoDB的根用户的密码。
• volumes:: 指定本地文件系统上的目录和容器内路径之间的挂载关系。
• - ./data:/data/db: 将本地的“data”目录挂载到容器内的“/data/db”路径，这是MongoDB默认的数据存储路径。
• ports:: 指定容器的端口映射。
• - "27017:27017": 将主机的27017端口映射到容器的27017端口，这是MongoDB的默认端口。

2.5 sqlserver

version: '3.0'
services:
  db:
    image: mcr.microsoft.com/mssql/server:2017-latest
    restart: always
    container_name: sqlserver
    environment:
      ACCEPT_EULA: Y
      SA_PASSWORD: 123456
    ports:
      - 1433:1433
    volumes:
      - ./mssql:/var/opt/mssql

• db:: 定义一个名为“db”的服务，这将是SQL Server数据库服务器。
• image: mcr.microsoft.com/mssql/server:2017-latest: 指定使用的SQL Server镜像，这里是2017版本的最新版本。
• restart: always: 容器退出后自动重启。
• container_name: sqlserver: 指定容器的名称为“sqlserver”。
• environment:: 指定容器的环境变量。
• ACCEPT_EULA: Y: 设置环境变量ACCEPT_EULA为Y，表示接受最终用户许可协议。
• SA_PASSWORD: 123456: 设置环境变量SA_PASSWORD为123456，这是SQL Server的系统管理员(SA)账户的密码。
• ports:: 指定容器的端口映射。
• - 1433:1433: 将主机的1433端口映射到容器的1433端口，这是SQL Server的默认端口。
• volumes:: 指定本地文件系统上的目录和容器内路径之间的挂载关系。
• - ./mssql:/var/opt/mssql: 将本地的“mssql”目录挂载到容器内的“/var/opt/mssql”路径。

3. 消息队列和事件驱动系统

3.1 ActiveMQ

version: '3'
services:
  activemq:
    image: rmohr/activemq:latest
    container_name: my_activemq
    ports:
      - "61616:61616"
      - "8161:8161"
    volumes:
      - ./data:/var/lib/activemq

定义了一个名为 activemq 的服务，使用了 rmohr/activemq 镜像。这个镜像包含了 ActiveMQ，并且映射了主机的端口 61616（用于消息传递）和 8161（用于管理界面）到容器内相应的端口。还挂载了一个卷，将 ActiveMQ 数据目录映射到主机上的 ./data 目录。

3.2 RabbitMQ

version: '3'
services:
  activemq:
    image: rmohr/activemq:latest
    container_name: my_activemq
    ports:
      - "61616:61616"
      - "8161:8161"
    volumes:
      - ./data:/var/lib/activemq

定义了一个名为 rabbitmq 的服务，使用了 RabbitMQ 官方镜像。映射了主机的端口 5672（用于 AMQP）和 15672（用于 RabbitMQ 管理界面）到容器内相应的端口。还挂载了一个卷，将 RabbitMQ 数据目录映射到主机上的 ./data 目录。

3.3 Apache Kafka

version: '2'
services:
  zookeeper:
    image: wurstmeister/zookeeper:latest
    container_name: my_zookeeper
    ports:
      - "2181:2181"

  kafka:
    image: wurstmeister/kafka:latest
    container_name: my_kafka
    ports:
      - "9092:9092"
    expose:
      - "9093"
    environment:
      KAFKA_ADVERTISED_LISTENERS: INSIDE://kafka:9093,OUTSIDE://localhost:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INSIDE:PLAINTEXT,OUTSIDE:PLAINTEXT
      KAFKA_LISTENERS: INSIDE://0.0.0.0:9093,OUTSIDE://0.0.0.0:9092
      KAFKA_INTER_BROKER_LISTENER_NAME: INSIDE
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_CREATE_TOPICS: "my-topic:1:1"

定义了两个服务，zookeeper 和 kafka。zookeeper 使用了 wurstmeister 提供的 Zookeeper 镜像，kafka 使用了 wurstmeister 提供的 Kafka 镜像。zookeeper 服务监听主机的端口 2181，kafka 服务监听主机的端口 9092（用于外部访问）。还设置了一些环境变量来配置 Kafka。注意 KAFKA_CREATE_TOPICS 变量，用于在启动时创建一个名为 my-topic 的主题。

3.4 NATS

version: '3'
services:
  nats-server:
    image: nats:latest
    container_name: my-nats-container
    ports:
      - "4222:4222"
      - "6222:6222"
      - "8222:8222"

  nats-publisher:
    image: nats:latest
    container_name: my-nats-publisher
    command: nats-pub -s nats://nats-server:4222 my_subject "Hello NATS!"
    depends_on:
      - nats-server

• nats-server服务使用官方NATS镜像，并将容器的4222、6222和8222端口映射到主机上。这些端口用于客户端连接、集群通信和监控。
• nats-publisher服务也使用NATS镜像，并依赖于nats-server服务。它的命令是在启动时使用nats-pub发布一条消息到NATS服务器。

4. 缓存和内存数据存储

4.1 Redis

version: '3'
services:
  redis:
    image: redis:latest
    container_name: my-redis-container
    ports:
      - "6379:6379"
    volumes:
      - ./redis-data:/data
    command: redis-server --appendonly yes
    environment:
      - REDIS_REPLICATION_MODE=master
      - REDIS_PASSWORD=123456

• image: redis:latest 指定使用官方的Redis镜像。
• container_name: my-redis-container 指定Redis容器的名称。
• ports: - "6379:6379" 将容器的6379端口映射到主机的6379端口。
• volumes: - ./redis-data:/data 将Redis数据目录映射到主机上，以实现数据的持久化。
• command: redis-server --appendonly yes 设置Redis容器启动时的命令，启用持久化。
• environment: - REDIS_REPLICATION_MODE=master - REDIS_PASSWORD=123456 设置Redis容器的环境变量，包括设置密码和主从复制模式。

4.2 Memcached

version: '3'
services:
  memcached:
    image: memcached:latest
    container_name: my-memcached-container
    ports:
      - "11211:11211"
    environment:
      - MEMCACHED_MEMORY_LIMIT=64 # 设置内存限制为64MB
      - MEMCACHED_LOG_FILE=/var/log/memcached/memcached.log
      - MEMCACHED_LOG_LEVEL=-vv # 设置日志级别为详细
    volumes:
      - ./memcached-data:/data
      - ./memcached-logs:/var/log/memcached

• memcached服务使用官方Memcached镜像，并将容器的11211端口映射到主机上。
• environment部分包含了一些环境变量，如MEMCACHED_MEMORY_LIMIT用于设置内存限制，MEMCACHED_LOG_FILE用于指定日志文件的路径，MEMCACHED_LOG_LEVEL用于设置日志级别。
• volumes部分将容器内的/data目录映射到主机上的./memcached-data目录，以及将/var/log/memcached目录映射到主机上的./memcached-logs目录，实现数据和日志的持久化。

5. 分布式文件系统

5.1 FastDFS

FastDFS是一个开源的分布式文件系统，旨在提供高性能、高可靠性的文件存储解决方案。通常用于分布式存储大量小文件，比如图片、音频和视频等。

version: '3.3'
services:
  tracker:
    image: season/fastdfs:1.2
    container_name: tracker
    network_mode: host
    restart: always
    ports:
      - "22122:22122"
    command: "tracker"

  storage:
    image: season/fastdfs:1.2
    container_name: storage
    network_mode: host
    restart: always
    volumes:
      - "./storage.conf:/fdfs_conf/storage.conf"
      - "./storage_base_path:/fastdfs/storage/data"
      - "./store_path0:/fastdfs/store_path"
    environment:
      TRACKER_SERVER: "192.168.1.100:22122"
    command: "storage"

  nginx:
    image: season/fastdfs:1.2
    container_name: fdfs-nginx
    restart: always
    network_mode: host
    volumes:
      - "./nginx.conf:/etc/nginx/conf/nginx.conf"
      - "./store_path0:/fastdfs/store_path"
    environment:
      TRACKER_SERVER: "192.168.1.100:22122"
    command: "nginx"

配置文件

storage.conf

# the name of the group this storage server belongs to
group_name=group1

# bind an address of this host
# empty for bind all addresses of this host
bind_addr=

# if bind an address of this host when connect to other servers
# (this storage server as a client)
# true for binding the address configed by above parameter: "bind_addr"
# false for binding any address of this host
client_bind=true

# the storage server port
port=23000

# connect timeout in seconds
# default value is 30s
connect_timeout=30

# network timeout in seconds
# default value is 30s
network_timeout=60

# heart beat interval in seconds
heart_beat_interval=30

# disk usage report interval in seconds
stat_report_interval=60

# the base path to store data and log files
base_path=/fastdfs/storage

# max concurrent connections the server supported
# default value is 256
# more max_connections means more memory will be used
max_connections=256

# the buff size to recv / send data
# this parameter must more than 8KB
# default value is 64KB
# since V2.00
buff_size = 256KB

# accept thread count
# default value is 1
# since V4.07
accept_threads=1

# work thread count, should <= max_connections
# work thread deal network io
# default value is 4
# since V2.00
work_threads=4

# if disk read / write separated
##  false for mixed read and write
##  true for separated read and write
# default value is true
# since V2.00
disk_rw_separated = true

# disk reader thread count per store base path
# for mixed read / write, this parameter can be 0
# default value is 1
# since V2.00
disk_reader_threads = 1

# disk writer thread count per store base path
# for mixed read / write, this parameter can be 0
# default value is 1
# since V2.00
disk_writer_threads = 1

# when no entry to sync, try read binlog again after X milliseconds
# must > 0, default value is 200ms
sync_wait_msec=50

# after sync a file, usleep milliseconds
# 0 for sync successively (never call usleep)
sync_interval=0

# storage sync start time of a day, time format: Hour:Minute
# Hour from 0 to 23, Minute from 0 to 59
sync_start_time=00:00

# storage sync end time of a day, time format: Hour:Minute
# Hour from 0 to 23, Minute from 0 to 59
sync_end_time=23:59

# write to the mark file after sync N files
# default value is 500
write_mark_file_freq=500

# path(disk or mount point) count, default value is 1
store_path_count=1

# store_path#, based 0, if store_path0 not exists, it's value is base_path
# the paths must be exist
store_path0=/fastdfs/store_path
#store_path1=/home/yuqing/fastdfs2

# subdir_count  * subdir_count directories will be auto created under each
# store_path (disk), value can be 1 to 256, default value is 256
subdir_count_per_path=256

# tracker_server can ocur more than once, and tracker_server format is
#  "host:port", host can be hostname or ip address
tracker_server=192.168.1.100:22122

#standard log level as syslog, case insensitive, value list:
### emerg for emergency
### alert
### crit for critical
### error
### warn for warning
### notice
### info
### debug
log_level=info

#unix group name to run this program,
#not set (empty) means run by the group of current user
run_by_group=

#unix username to run this program,
#not set (empty) means run by current user
run_by_user=

# allow_hosts can ocur more than once, host can be hostname or ip address,
# "*" means match all ip addresses, can use range like this: 10.0.1.[1-15,20] or
# host[01-08,20-25].domain.com, for example:
# allow_hosts=10.0.1.[1-15,20]
# allow_hosts=host[01-08,20-25].domain.com
allow_hosts=*

# the mode of the files distributed to the data path
# 0: round robin(default)
# 1: random, distributted by hash code
file_distribute_path_mode=0

# valid when file_distribute_to_path is set to 0 (round robin),
# when the written file count reaches this number, then rotate to next path
# default value is 100
file_distribute_rotate_count=100

# call fsync to disk when write big file
# 0: never call fsync
# other: call fsync when written bytes >= this bytes
# default value is 0 (never call fsync)
fsync_after_written_bytes=0

# sync log buff to disk every interval seconds
# must > 0, default value is 10 seconds
sync_log_buff_interval=10

# sync binlog buff / cache to disk every interval seconds
# default value is 60 seconds
sync_binlog_buff_interval=10

# sync storage stat info to disk every interval seconds
# default value is 300 seconds
sync_stat_file_interval=300

# thread stack size, should >= 512KB
# default value is 512KB
thread_stack_size=512KB

# the priority as a source server for uploading file.
# the lower this value, the higher its uploading priority.
# default value is 10
upload_priority=10

# the NIC alias prefix, such as eth in Linux, you can see it by ifconfig -a
# multi aliases split by comma. empty value means auto set by OS type
# default values is empty
if_alias_prefix=

# if check file duplicate, when set to true, use FastDHT to store file indexes
# 1 or yes: need check
# 0 or no: do not check
# default value is 0
check_file_duplicate=0

# file signature method for check file duplicate
## hash: four 32 bits hash code
## md5: MD5 signature
# default value is hash
# since V4.01
file_signature_method=hash

# namespace for storing file indexes (key-value pairs)
# this item must be set when check_file_duplicate is true / on
key_namespace=FastDFS

# set keep_alive to 1 to enable persistent connection with FastDHT servers
# default value is 0 (short connection)
keep_alive=0

# you can use "#include filename" (not include double quotes) directive to
# load FastDHT server list, when the filename is a relative path such as
# pure filename, the base path is the base path of current/this config file.
# must set FastDHT server list when check_file_duplicate is true / on
# please see INSTALL of FastDHT for detail
##include /home/yuqing/fastdht/conf/fdht_servers.conf

# if log to access log
# default value is false
# since V4.00
use_access_log = false

# if rotate the access log every day
# default value is false
# since V4.00
rotate_access_log = false

# rotate access log time base, time format: Hour:Minute
# Hour from 0 to 23, Minute from 0 to 59
# default value is 00:00
# since V4.00
access_log_rotate_time=00:00

# if rotate the error log every day
# default value is false
# since V4.02
rotate_error_log = false

# rotate error log time base, time format: Hour:Minute
# Hour from 0 to 23, Minute from 0 to 59
# default value is 00:00
# since V4.02
error_log_rotate_time=00:00

# rotate access log when the log file exceeds this size
# 0 means never rotates log file by log file size
# default value is 0
# since V4.02
rotate_access_log_size = 0

# rotate error log when the log file exceeds this size
# 0 means never rotates log file by log file size
# default value is 0
# since V4.02
rotate_error_log_size = 0

# if skip the invalid record when sync file
# default value is false
# since V4.02
file_sync_skip_invalid_record=false

# if use connection pool
# default value is false
# since V4.05
use_connection_pool = false

# connections whose the idle time exceeds this time will be closed
# unit: second
# default value is 3600
# since V4.05
connection_pool_max_idle_time = 3600

# use the ip address of this storage server if domain_name is empty,
# else this domain name will ocur in the url redirected by the tracker server
http.domain_name=

tracker_server=192.168.1.100:22122

# the port of the web server on this storage server
http.server_port=8888

nginx.conf

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       8088;
        server_name  localhost;

        #charset koi8-r;

        #缩略图需要使用插件，需要单独构建nginx镜像，此处忽略
        #location /group([0-9])/M00/.*\.(gif|jpg|jpeg|png)$ {
         #   root /fastdfs/storage/data;
         #   image on;
         #   image_output off;
         #   image_jpeg_quality 75;
         #   image_backend off;
        #    image_backend_server http://baidu.com/docs/aabbc.png;
       # }

        # group1
        location /group1/M00 {
        # 文件存储目录
            root /fastdfs/storage/data;
            ngx_fastdfs_module;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
 }
}

5.2 GlusterFS

GlusterFS是一个开源的分布式文件系统，允许将多个存储服务器汇聚成一个统一的存储池，提供高可用性和可扩展性。

version: '3'
services:
  glusterfs-server-1:
    image: gluster/gluster-centos
    container_name: glusterfs-server-1
    privileged: true
    command: /usr/sbin/init
    network_mode: host
    volumes:
      - /data/brick1

  glusterfs-server-2:
    image: gluster/gluster-centos
    container_name: glusterfs-server-2
    privileged: true
    command: /usr/sbin/init
    network_mode: host
    volumes:
      - /data/brick2

  glusterfs-client:
    image: gluster/gluster-centos
    container_name: glusterfs-client
    privileged: true
    command: /usr/sbin/init
    network_mode: host
    depends_on:
      - glusterfs-server-1
      - glusterfs-server-2
    volumes:
      - /mnt/glusterfs

networks:
  default:
    external:
      name: host

定义了三个服务：glusterfs-server-1、glusterfs-server-2和glusterfs-client。两个glusterfs-server服务表示两个GlusterFS存储节点，而glusterfs-client服务是一个GlusterFS客户端。使用了GlusterFS官方提供的Docker镜像，并设置了privileged: true以获取必要的权限。

5.3 MooseFS

MooseFS是一个开源的分布式文件系统，旨在提供高性能、高可用性的分布式存储解决方案。

version: '3'
services:
  # MooseFS Master节点
  mfsmaster:
    image: moosefs/moosefs:latest
    container_name: mfsmaster
    command: /bin/bash -c "mfsmaster start && mfschunkmaster start && tail -f /dev/null"
    ports:
      - "9419:9419"
    networks:
      - moosefs_net
    restart: always

  # MooseFS Metadata服务器节点
  mfsmeta:
    image: moosefs/moosefs:latest
    container_name: mfsmeta
    command: /bin/bash -c "mfsmetarestore start && tail -f /dev/null"
    networks:
      - moosefs_net
    restart: always

  # MooseFS Chunk服务器节点
  mfschunk:
    image: moosefs/moosefs:latest
    container_name: mfschunk
    command: /bin/bash -c "mfschunkserver start && tail -f /dev/null"
    networks:
      - moosefs_net
    restart: always

  # MooseFS CGI服务器节点
  mfscgiserv:
    image: moosefs/moosefs:latest
    container_name: mfscgiserv
    command: /bin/bash -c "mfscgiserv start && tail -f /dev/null"
    networks:
      - moosefs_net
    restart: always

networks:
  moosefs_net:

mfsmaster:

• image: 使用moosefs/moosefs镜像，该镜像包含MooseFS的主节点（Master）。
• container_name: 设置容器的名称为mfsmaster。
• command: 启动MooseFS Master节点和Chunk Master节点，以及tail -f /dev/null以保持容器运行。
• ports: 将宿主机的9419端口映射到容器的9419端口，用于MooseFS监控。
• networks: 使用名为moosefs_net的自定义网络。
• restart: 总是在容器退出时重新启动。

mfsmeta:

• 同上，这是MooseFS的Metadata服务器节点的配置。

mfschunk:

• 同上，这是MooseFS的Chunk服务器节点的配置。

mfscgiserv:

• 同上，这是MooseFS的CGI服务器节点的配置。

networks:

• 定义一个自定义网络moosefs_net，用于连接MooseFS的各个节点。

5.4 Ceph

Ceph是一个开源的分布式存储系统，具有高性能、高可用性和可扩展性。

version: '3'
services:
  mon:
    image: ceph/daemon:latest-luminous
    container_name: ceph-mon
    net: host
    environment:
      - CEPH_DAEMON=mon
      - MON_IP=192.168.1.100
      - CEPH_PUBLIC_NETWORK=your_public_network
    volumes:
      - /var/lib/ceph/mon/ceph-mon:/var/lib/ceph/mon/ceph-mon
    restart: always

  mgr:
    image: ceph/daemon:latest-luminous
    container_name: ceph-mgr
    net: host
    environment:
      - CEPH_DAEMON=mgr
      - MON_IP=192.168.1.100
    restart: always

  osd:
    image: ceph/daemon:latest-luminous
    container_name: ceph-osd
    net: host
    privileged: true
    environment:
      - OSD_DEVICE=/dev/sdb
      - OSD_FORCE_ZAP=1
      - MON_IP=192.168.1.100
    volumes:
      - /var/lib/ceph/osd/ceph-osd:/var/lib/ceph/osd/ceph-osd
    restart: always

networks:
  host_net:
    external: true
    name: host

定义了三个服务：mon、mgr和osd。这些服务分别代表Ceph的Monitor、Manager和Object Storage Daemon。

在这个配置中，使用了Ceph官方提供的Docker镜像，并设置了相应的环境变量。请替换192.168.1.100和your_public_network为你的Monitor节点的IP地址和公共网络信息。

• mon:
  • 使用ceph/daemon镜像，代表Monitor节点。
  • 设置MON_IP为Monitor节点的IP地址。
  • volumes将Monitor节点的数据存储在宿主机的/var/lib/ceph/mon/ceph-mon目录中。
• mgr:
  • 使用ceph/daemon镜像，代表Manager节点。
  • 设置MON_IP为Monitor节点的IP地址。
• osd:
  • 使用ceph/daemon镜像，代表Object Storage Daemon节点。
  • 设置OSD_DEVICE为你要用于存储的设备（替换为实际的设备路径）。
  • volumes将OSD节点的数据存储在宿主机的/var/lib/ceph/osd/ceph-osd目录中。

6. 搜索和索引服务

6.1 Elasticsearch

version: '3'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.14.0
    container_name: my-elasticsearch-container
    environment:
      - discovery.type=single-node
    ports:
      - "9200:9200"
      - "9300:9300"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    mem_limit: 2g
    volumes:
      - ./elasticsearch-data:/usr/share/elasticsearch/data

• elasticsearch服务使用Elasticsearch的官方Docker镜像，并将容器的9200和9300端口映射到主机上。
• environment部分包含了一些环境变量，其中discovery.type=single-node表示将Elasticsearch配置为单节点。
• ulimits和mem_limit部分用于设置内存锁定（mlockall），这是Elasticsearch的一个推荐设置。
• volumes部分将容器内的/usr/share/elasticsearch/data目录映射到主机上的./elasticsearch-data目录，以实现数据的持久化。

6.2 Solr

version: '3'
services:
  solr:
    image: solr:8.11.0
    container_name: my-solr-container
    ports:
      - "8983:8983"
    environment:
      - SOLR_CORE=mycore
    volumes:
      - ./solr-data:/opt/solr/server/solr/mycore/data

• solr服务使用Solr的官方Docker镜像，并将容器的8983端口映射到主机上。
• environment部分包含了一个环境变量SOLR_CORE，用于指定Solr的核心（索引）名称。在这个例子中，核心名称为mycore。
• volumes部分将容器内的/opt/solr/server/solr/mycore/data目录映射到主机上的./solr-data目录，以实现数据的持久化。

7. 服务发现

7.1 Nacos

version: '3'
services:
  nacos-server:
    image: nacos/nacos-server:latest
    ports:
      - "8848:8848"
    environment:
      - PREFER_HOST_MODE=hostname
    command: -e embeddedStorage=true

  nacos-mysql:
    image: mysql:5.7
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE=nacos
      - MYSQL_USER=nacos
      - MYSQL_PASSWORD=nacos
    command: --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

  nacos-redis:
    image: redis:latest
    ports:
      - "6379:6379"

  nacos-config:
    image: nacos/nacos-config:latest
    ports:
      - "8849:8849"
    environment:
      - PREFER_HOST_MODE=hostname
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=nacos-mysql
      - MYSQL_SERVICE_PORT=3306
      - MYSQL_SERVICE_DB_NAME=nacos
      - REDIS_SERVICE_HOST=nacos-redis
      - REDIS_SERVICE_PORT=6379
      - NACOS_SERVER_ADDR=nacos-server:8848

  nacos-console:
    image: nacos/nacos-console:latest
    ports:
      - "8849:8849"
    environment:
      - SPRING_DATASOURCE_PLATFORM=mysql
      - MYSQL_SERVICE_HOST=nacos-mysql
      - MYSQL_SERVICE_PORT=3306
      - MYSQL_SERVICE_DB_NAME=nacos
      - REDIS_SERVICE_HOST=nacos-redis
      - REDIS_SERVICE_PORT=6379
      - NACOS_SERVER_ADDR=nacos-server:8848

nacos-server 服务：

• 使用 nacos/nacos-server:latest 镜像，该镜像包含了 Nacos 服务端组件。
• 将 Nacos 服务端暴露在主机的 8848 端口。
• 设置了 PREFER_HOST_MODE=hostname 环境变量，使用主机名作为服务注册的方式。
• 使用 -e embeddedStorage=true 命令启用嵌入式存储。

nacos-mysql 服务：

• 使用官方的 mysql:5.7 镜像。
• 设置 MySQL 的相关环境变量，包括用户名、密码等。

nacos-redis 服务：

• 使用官方的 redis:latest 镜像。
• 将 Redis 服务暴露在主机的 6379 端口。

nacos-config 服务：

• 使用 nacos/nacos-config:latest 镜像，该镜像包含了 Nacos 的配置中心组件。
• 将 Nacos 配置中心暴露在主机的 8849 端口。
• 设置了与 MySQL、Redis、Nacos 服务端的连接信息。

nacos-console 服务：

• 使用 nacos/nacos-console:latest 镜像，该镜像包含了 Nacos 控制台组件。
• 将 Nacos 控制台暴露在主机的 8849 端口。
• 设置了与 MySQL、Redis、Nacos 服务端的连接信息。

7.2 Consul

由HashiCorp提供，是一个开源的服务发现和配置工具。

version: '3'
services:
  consul:
    image: consul:latest
    container_name: my-consul
    command: agent -server -bootstrap-expect=1 -ui -client=0.0.0.0
    ports:
      - "8500:8500"
      - "8600:8600/udp"
    volumes:
      - ./consul-data:/consul/data
    networks:
      - consul-net

networks:
  consul-net:
    driver: bridge

• version: '3': 指定 Docker Compose 文件的版本。
• services: 定义了要部署的服务列表。
• consul: 定义了一个名为 consul 的服务。
  • image: consul:latest: 使用 Consul 的官方 Docker 镜像，你可以根据需要指定特定版本。
  • container_name: my-consul: 设置 Docker 容器的名称为 my-consul。
  • command: agent -server -bootstrap-expect=1 -ui -client=0.0.0.0: 配置 Consul Agent 的启动命令。这里将其配置为 Consul 服务器 (-server) 模式，并启用 Web UI (-ui)。-bootstrap-expect=1 表示这是一个单节点的 Consul 集群。
  • ports: 将容器内的端口映射到主机上。8500端口用于Consul的Web UI，8600端口用于DNS查询。
  • volumes: 将容器内的数据目录映射到主机上，以确保 Consul 数据持久化。
  • networks: 定义了一个名为 consul-net 的自定义网络。
• networks: 配置自定义网络 consul-net，以确保 Consul 容器可以通过该网络通信。

7.3 ZooKeeper

Zookeeper 是一个开源的分布式协调服务，它提供了一个简单而强大的分布式应用程序协调系统。

version: '3'

services:
  zookeeper:
    image: wurstmeister/zookeeper:3.4.6
    container_name: zookeeper
    ports:
      - "2181:2181"  # 映射 Zookeeper 默认端口到主机
    environment:
      ZOO_MY_ID: 1  # 设置 Zookeeper 节点的 ID
      ZOO_SERVERS: server.1=zookeeper:2888:3888  # 定义 Zookeeper 集群中的服务器列表
    volumes:
      - ./data:/data  # 映射数据目录到主机
      - ./datalog:/datalog  # 映射事务日志目录到主机
    restart: always  # 始终在容器退出时重新启动

networks:
  default:
    external:
      name: zookeeper-net  # 使用外部创建的网络

7.4 Etcd

Etcd 是一个高可用的键值存储系统，主要用于配置共享和服务发现。

version: '3'
services:
  etcd:
    image: quay.io/coreos/etcd:v3.4.13
    container_name: etcd
    command: ["etcd", "--data-dir=/etcd-data", "--name=etcd-node1", "--advertise-client-urls=http://0.0.0.0:2379", "--listen-client-urls=http://0.0.0.0:2379", "--initial-advertise-peer-urls=http://0.0.0.0:2380", "--listen-peer-urls=http://0.0.0.0:2380", "--initial-cluster=etcd-node1=http://etcd:2380", "--initial-cluster-token=etcd-cluster-token", "--initial-cluster-state=new"]
    ports:
      - "2379:2379"
      - "2380:2380"
    volumes:
      - ./etcd-data:/etcd-data
    restart: always

networks:
  default:
    external:
      name: etcd-net

• image: 使用的 Etcd 镜像版本。在这个例子中，使用的是 quay.io/coreos/etcd:v3.4.13。可以根据需要选择其他版本。

• container_name: 指定容器的名称，方便引用容器。

• command: 指定 Etcd 运行时的命令行参数，包括数据目录、节点名称、广告和监听地址、初始集群配置等。

• ports: 映射 Etcd 默认端口到主机。

• volumes: 映射 Etcd 数据目录到主机，以确保数据在容器停止或删除后仍然保留在主机上。

• restart: 配置容器的重启策略，确保 Etcd 服务在容器退出时重新启动。

• networks: 定义了一个外部网络 etcd-net，以确保容器之间可以相互通信。

8. 日志收集和分析

8.1 Fluentd

Fluentd 是一个用于数据收集和日志转发的开源工具。

version: '3'
services:
  fluentd:
    image: fluent/fluentd:latest
    container_name: fluentd
    volumes:
      - ./fluentd/conf:/fluentd/etc
    environment:
      - FLUENTD_CONF=fluent.conf
      - TZ=UTC
    ports:
      - "24224:24224"
      - "24224:24224/udp"

• fluentd 服务使用了 Fluentd 的官方 Docker 镜像，用于运行 Fluentd。
• volumes 将主机的 ./fluentd/conf 目录映射到容器内的 /fluentd/etc 目录。这是为了将 Fluentd 配置文件 fluent.conf 放在主机上，以便进行自定义配置。
• environment 设置了一些环境变量，包括 FLUENTD_CONF，用于指定 Fluentd 的配置文件名，以及 TZ 用于设置时区。
• ports 定义了容器和主机之间的端口映射关系，包括将主机的 24224 端口映射到容器的 24224 端口，同时支持 UDP 协议。

在 ./fluentd/conf 目录下创建一个 fluent.conf 配置文件，可以根据实际需求进行自定义配置。

  @type forward
  port 24224
  bind 0.0.0.0



  @type stdout

8.2 Logstash

Logstash 是 Elastic Stack 中的组件之一，用于数据处理和转发。

version: '3'
services:
  logstash:
    image: docker.elastic.co/logstash/logstash:7.10.0
    container_name: logstash
    volumes:
      - ./logstash/pipeline:/usr/share/logstash/pipeline
      - ./logstash/config:/usr/share/logstash/config
    ports:
      - "5000:5000"
    environment:
      - "LS_JAVA_OPTS=-Xmx256m -Xms256m"

• logstash 服务使用了 Elastic 提供的 Logstash 的官方 Docker 镜像，用于运行 Logstash。
• volumes 将主机的 ./logstash/pipeline 目录映射到容器内的 /usr/share/logstash/pipeline 目录，用于存放 Logstash 配置文件，同时将 ./logstash/config 目录映射到容器内的 /usr/share/logstash/config 目录，用于存放 Logstash 配置。
• ports 定义了容器和主机之间的端口映射关系，将主机的 5000 端口映射到容器的 5000 端口。
• environment 设置了 Logstash 的 Java 运行参数。

在 ./logstash/pipeline 目录下创建 Logstash 配置文件，例如 logstash.conf。

input {
  tcp {
    port => 5000
  }
}

filter {
  # 添加需要的过滤规则
}

output {
  stdout { codec => rubydebug }
}

8.3 Graylog

Graylog 是一款用于日志管理和分析的开源工具。它提供了强大的日志聚合、搜索、可视化和分析功能，旨在帮助用户更轻松地处理和理解大量的日志数据。部署 Graylog 通常涉及多个组件，包括 Graylog 服务器、MongoDB 数据库和 Elasticsearch。

version: '3'
services:
  # MongoDB
  mongo:
    image: mongo:4.4
    container_name: mongo
    volumes:
      - ./mongo/data:/data/db
    environment:
      - MONGO_INITDB_ROOT_USERNAME=admin
      - MONGO_INITDB_ROOT_PASSWORD=admin_password
      - MONGO_INITDB_DATABASE=graylog

  # Elasticsearch
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.14.0
    container_name: elasticsearch
    volumes:
      - ./elasticsearch/data:/usr/share/elasticsearch/data
    environment:
      - discovery.type=single-node
      - cluster.name=graylog
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"

  # Graylog
  graylog:
    image: graylog/graylog:4.2
    container_name: graylog
    depends_on:
      - mongo
      - elasticsearch
    ports:
      - "9000:9000"
      - "12201:12201/udp"
    environment:
      - GRAYLOG_HTTP_EXTERNAL_URI=http://127.0.0.1:9000/
      - GRAYLOG_PASSWORD_SECRET=somepasswordpepper
      - GRAYLOG_ROOT_PASSWORD_SHA2=8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
      - GRAYLOG_HTTP_BIND_ADDRESS=0.0.0.0
    links:
      - mongo:mongo
      - elasticsearch:elasticsearch

• mongo 服务使用了 MongoDB 的官方 Docker 镜像，用于存储 Graylog 数据。
• elasticsearch 服务使用了 Elasticsearch 的官方 Docker 镜像，用于存储 Graylog 索引。
• graylog 服务使用了 Graylog 的官方 Docker 镜像，包括 Graylog 服务器和 Web 界面。

请注意：

• 在 mongo 服务中，MONGO_INITDB_ROOT_USERNAME、MONGO_INITDB_ROOT_PASSWORD 和 MONGO_INITDB_DATABASE 分别设置 MongoDB 的管理员用户名、密码和数据库名。
• 在 elasticsearch 服务中，discovery.type 设置为 single-node，表示 Elasticsearch 将以单节点模式运行。
• 在 graylog 服务中，depends_on 指定了依赖的服务（mongo 和 elasticsearch），确保它们在 Graylog 启动之前启动。
• Graylog 的用户名和密码通过 GRAYLOG_ROOT_PASSWORD_SHA2 设置，可以通过使用 echo -n yourpassword | shasum -a 256 来生成密码的 SHA-256 散列。

8.4 Kibana

Kibana 是 Elastic Stack 中的一个组件，用于数据可视化和分析。

docker-compose.yml文件

version: '3'
services:
  kibana:
    image: docker.elastic.co/kibana/kibana:7.14.0
    container_name: kibana
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    ports:
      - "5601:5601"

• kibana 服务使用了 Elastic 提供的 Kibana 的官方 Docker 镜像，用于运行 Kibana。
• environment 设置了 Kibana 的环境变量，其中 ELASTICSEARCH_HOSTS 指定了 Elasticsearch 的地址和端口。
• ports 定义了容器和主机之间的端口映射关系，将主机的 5601 端口映射到容器的 5601 端口。

9. 监控系统和告警服务

9.1 Prometheus

Prometheus 是一个功能强大的监控工具，可以用于收集和存储系统的指标，并提供灵活的查询语言 PromQL。它还支持警报和图形化的仪表板，使得对系统性能进行实时监控变得更加容易。

docker-compose.yml文件

version: '3'
services:
  prometheus:
    image: prom/prometheus:v2.30.0
    container_name: prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./prometheus/data:/prometheus

• prometheus 服务使用了 Prometheus 的官方 Docker 镜像 prom/prometheus:v2.30.0。
• container_name 指定了容器的名称为 prometheus。
• command 字段指定了 Prometheus 启动时的命令参数，包括配置文件路径和存储路径。
• ports 定义了容器和主机之间的端口映射关系，将主机的 9090 端口映射到容器的 9090 端口。
• volumes 将主机上的 ./prometheus/prometheus.yml 文件映射到容器的 /etc/prometheus/prometheus.yml，以及将主机上的 ./prometheus/data 目录映射到容器的 /prometheus，用于存储 Prometheus 的数据。

在 ./prometheus 目录下创建一个 prometheus.yml 配置文件，用于配置 Prometheus 的监控目标和规则。

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  # Add additional scrape configurations as needed

• scrape_interval 指定了 Prometheus 抓取指标的时间间隔为 15 秒。
• scrape_configs 部分定义了抓取配置。在这个例子中，仅监控 Prometheus 本身的指标。你可以根据需要添加更多的 job 和 targets。

9.2 Grafana

Grafana 是一个开源的数据可视化和监控平台，它支持多种数据源，并提供丰富的图表和仪表板功能。

version: '3'
services:
  grafana:
    image: grafana/grafana:8.1.5
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - ./grafana/data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
      - ./grafana/dashboards:/var/lib/grafana/dashboards
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

• grafana 服务使用了 Grafana 的官方 Docker 镜像 grafana/grafana:8.1.5。
• container_name 指定了容器的名称为 grafana。
• ports 定义了容器和主机之间的端口映射关系，将主机的 3000 端口映射到容器的 3000 端口。
• volumes 将主机上的 ./grafana/data 目录映射到容器的 /var/lib/grafana，用于存储 Grafana 数据；将 ./grafana/provisioning 目录映射到容器的 /etc/grafana/provisioning，用于配置数据源和仪表板；将 ./grafana/dashboards 目录映射到容器的 /var/lib/grafana/dashboards，用于存储自定义的仪表板。
• environment 设置了 Grafana 的环境变量，其中 GF_SECURITY_ADMIN_PASSWORD 指定了管理员用户的密码。

在 ./grafana/provisioning/datasources 目录下创建一个数据源配置文件 prometheus.yml：

apiVersion: 1

datasources:
- name: Prometheus
  type: prometheus
  access: proxy
  url: http://prometheus:9090
  basicAuth: false
  isDefault: true
  editable: true

9.3 Zabbix

Zabbix 是一款用于监控和管理网络、服务器、虚拟机和各种网络设备的开源软件。

version: '3'
services:
  zabbix-server:
    image: zabbix/zabbix-server-pgsql:alpine-5.4-latest
    container_name: zabbix-server
    ports:
      - "10051:10051"
    environment:
      - DB_SERVER_HOST=zabbix-db
      - POSTGRES_DB=zabbix
      - POSTGRES_USER=zabbix
      - POSTGRES_PASSWORD=zabbix
      - ZBX_SERVER_NAME=zabbix-server

  zabbix-web:
    image: zabbix/zabbix-web-nginx-pgsql:alpine-5.4-latest
    container_name: zabbix-web
    ports:
      - "8080:8080"
    environment:
      - DB_SERVER_HOST=zabbix-db
      - POSTGRES_DB=zabbix
      - POSTGRES_USER=zabbix
      - POSTGRES_PASSWORD=zabbix
      - ZBX_SERVER_NAME=zabbix-server
      - PHP_TZ=UTC

  zabbix-db:
    image: postgres:13-alpine
    container_name: zabbix-db
    environment:
      - POSTGRES_DB=zabbix
      - POSTGRES_USER=zabbix
      - POSTGRES_PASSWORD=zabbix

• zabbix-server 服务使用了 Zabbix Server 的官方 Docker 镜像 zabbix/zabbix-server-pgsql:alpine-5.4-latest。它负责运行 Zabbix 服务器，监听端口 10051。
• zabbix-web 服务使用了 Zabbix Web 的官方 Docker 镜像 zabbix/zabbix-web-nginx-pgsql:alpine-5.4-latest。它负责运行 Zabbix Web 界面，监听端口 8080。请注意，这个服务的配置需要与 zabbix-server 服务的配置相匹配。
• zabbix-db 服务使用了 PostgreSQL 的官方 Docker 镜像 postgres:13-alpine。它用作 Zabbix 的数据库，并将 Zabbix Server 和 Zabbix Web 连接到该数据库。请注意，这里的版本可能需要根据 Zabbix 版本进行调整。

在 ./zabbix 目录下创建一个名为 docker-compose.override.yml 的文件，用于指定 Zabbix 数据库的初始化 SQL 文件。

version: '3'
services:
  zabbix-db:
    volumes:
      - ./zabbix-db-init:/docker-entrypoint-initdb.d

在 ./zabbix-db-init 目录下，可以放置一个名为 schema.sql 的 SQL 文件，该文件包含 Zabbix 数据库的初始化脚本。

9.4 Nagios

Nagios 是一款广泛用于监控系统、网络和基础设施的开源工具。

version: '3'
services:
  nagios:
    image: jasonrivers/nagios:latest
    container_name: nagios
    ports:
      - "8080:80"
    environment:
      - NAGIOSADMIN_USER=admin
      - NAGIOSADMIN_PASS=adminpassword

  nagios-plugins:
    image: nagios-plugins:latest
    container_name: nagios-plugins
    depends_on:
      - nagios

• nagios 服务使用了 jasonrivers/nagios 镜像，该镜像包含了 Nagios Core 和一些常用的插件。它监听端口 8080，你可以通过访问 http://localhost:8080 来访问 Nagios Web 界面。
  • NAGIOSADMIN_USER 和 NAGIOSADMIN_PASS 环境变量设置了 Nagios 管理员用户的用户名和密码。
• nagios-plugins 服务使用了 Nagios Plugins 镜像。Nagios Plugins 包含了一系列用于监控各种服务和资源的插件。这个服务依赖于 nagios 服务，确保 Nagios Core 已经启动。

在 ./nagios 目录下创建一个名为 nagios.cfg 的配置文件，用于配置 Nagios 的基本设置。

# Define a host for the local machine
define host {
    use                     linux-server
    host_name               localhost
    alias                   localhost
    address                 127.0.0.1
    max_check_attempts      5
    check_period            24x7
    notification_interval  30
    notification_period    24x7
}

# Define a service to check the disk space of the root partition
define service {
    use                     local-service
    host_name               localhost
    service_description     Root Partition
    check_command           check_local_disk!20%!10%!/
    max_check_attempts      5
    check_interval          5
    retry_interval          3
    check_period            24x7
    notification_interval  30
    notification_period    24x7
}

配置文件定义了一个监控本地主机和根分区磁盘空间的服务。

10. CI/CD 工具

10.1 Jenkins

Jenkins 是一个开源的自动化服务器，用于构建、测试和部署软件。

version: '3'
services:
  jenkins:
    image: jenkins/jenkins:lts
    container_name: jenkins
    ports:
      - "8080:8080"
    volumes:
      - ./jenkins_home:/var/jenkins_home
    environment:
      - JAVA_OPTS=-Djenkins.install.runSetupWizard=false
      - JENKINS_OPTS=--prefix=/jenkins
    restart: always

• jenkins 服务使用了 Jenkins 官方的 Long Term Support (LTS) 版本的 Docker 镜像 jenkins/jenkins:lts。
• container_name 指定了容器的名称为 jenkins。
• ports 定义了容器和主机之间的端口映射关系，将主机的 8080 端口映射到容器的 8080 端口。
• volumes 将主机上的 ./jenkins_home 目录映射到容器的 /var/jenkins_home，用于存储 Jenkins 的数据。
• environment 设置了 Jenkins 的环境变量，其中 JAVA_OPTS 禁用了首次运行时的设置向导，JENKINS_OPTS 设置了 Jenkins 的路径前缀为 /jenkins。
• restart: always 设置容器总是在退出时重新启动。

10.2 Drone

Drone 是一个开源的持续集成和持续交付（CI/CD）平台，支持 Docker 容器。

version: '3'
services:
  drone-server:
    image: drone/drone:2
    container_name: drone-server
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./drone/server:/data
    environment:
      - DRONE_GITHUB_CLIENT_ID=YOUR_GITHUB_CLIENT_ID
      - DRONE_GITHUB_CLIENT_SECRET=YOUR_GITHUB_CLIENT_SECRET
      - DRONE_RPC_SECRET=YOUR_RPC_SECRET
      - DRONE_SERVER_HOST=your-drone-domain.com
      - DRONE_SERVER_PROTO=https
      - DRONE_USER_CREATE=username:your-github-username,admin:true
    restart: always

  drone-runner:
    image: drone/drone-runner-docker:2
    container_name: drone-runner
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - DRONE_RPC_PROTO=http
      - DRONE_RPC_SECRET=YOUR_RPC_SECRET
      - DRONE_RUNNER_CAPACITY=2
    restart: always

• drone-server 是 Drone 的服务端，负责处理构建和部署的请求。
• drone-runner 是 Drone 的运行器，负责在容器中执行构建任务。
• DRONE_GITHUB_CLIENT_ID 和 DRONE_GITHUB_CLIENT_SECRET 是用于与 GitHub 进行身份验证的 OAuth 应用程序的客户端 ID 和密钥。你需要在 GitHub 上创建一个 OAuth 应用程序，然后将这两个值配置到这里。
• DRONE_RPC_SECRET 是用于加密数据传输的密钥。确保为每个 Drone 部署生成一个唯一的密钥。
• DRONE_SERVER_HOST 是你的 Drone 服务的域名或 IP 地址。
• DRONE_SERVER_PROTO 指定 Drone 服务使用的协议，这里设置为 https。
• DRONE_USER_CREATE 用于在首次登录时创建管理员用户。你需要将 your-github-username 替换为你的 GitHub 用户名。

11. 代码仓库和版本控制服务

GitLab

GitLab 是一个用于管理代码仓库、进行协作开发和持续集成的开源平台。

version: '3'
services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    container_name: gitlab
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./gitlab/config:/etc/gitlab
      - ./gitlab/logs:/var/log/gitlab
      - ./gitlab/data:/var/opt/gitlab
    restart: always

• gitlab 服务使用了 GitLab CE（Community Edition）的官方 Docker 镜像 gitlab/gitlab-ce:latest。这是一个包含 GitLab 各个组件的完整镜像。
• container_name 指定了容器的名称为 gitlab。
• ports 定义了容器和主机之间的端口映射关系，将主机的 80 端口映射到容器的 80 端口（HTTP）以及将主机的 443 端口映射到容器的 443 端口（HTTPS）。
• volumes 将主机上的三个目录映射到容器内，分别用于存储 GitLab 的配置文件、日志和数据。
• restart: always 设置容器总是在退出时重新启动。

12. VPN 和远程访问服务

12.1 OpenVPN

OpenVPN 是一种开源的虚拟私人网络（VPN）解决方案，允许通过加密和隧道技术安全地连接到网络。

version: '3'
services:
  open:
    image: kylemanna/open:2.6.1
    container_name: open
    cap_add:
      - NET_ADMIN
    ports:
      - "1194:1194/udp"
    restart: always
    volumes:
      - ./open-data:/etc/open

networks:
  default:
    external:
      name: open-net

• image: 使用的 OpenVPN 镜像版本。在这个例子中，使用的是 kylemanna/open:2.6.1。可以根据需要选择其他版本。
• container_name: 指定容器的名称，方便引用容器。
• cap_add: 启用 NET_ADMIN 权限，以便容器可以配置网络。
• ports: 映射 OpenVPN 默认端口到主机。
• restart: 配置容器的重启策略，确保 OpenVPN 服务在容器退出时重新启动。
• volumes: 映射 OpenVPN 数据目录到主机，以确保配置文件和证书在容器停止或删除后仍然保留在主机上。

需要在启动服务前创建 OpenVPN 配置文件和证书。可以使用 OpenVPN 官方提供的 easyrsa 工具生成证书，具体步骤如下：

1. 创建并进入 open-data 目录：

   cd open-data
   

2. 执行以下命令初始化证书：

   docker run -v $PWD:/etc/open --rm kylemanna/open:2.6.1 o_genconfig -u udp://your_server_ip
   

   请将 your_server_ip 替换为的服务器公共 IP 地址。

3. 执行以下命令生成初始证书和密钥：

   docker run -v $PWD:/etc/open --rm -it kylemanna/open:2.6.1 o_initpki
   

4. 启动 OpenVPN 服务：

   docker-compose up -d
   

12.2 FRP

Frp（Fast Reverse Proxy）是一款用于反向代理的开源工具，它可以将本地服务通过外部服务器进行访问，实现内网穿透和端口映射。

version: '3'
services:
  frps:
    image: snowdreamtech/frps:0.37.1
    container_name: frps
    ports:
      - "7000:7000"
      - "7500:7500"
    restart: always
    volumes:
      - ./frps.ini:/etc/frp/frps.ini

networks:
  default:
    external:
      name: frp-net

• image: 使用的 Frp 镜像版本。在这个例子中，使用的是 snowdreamtech/frps:0.37.1。可以根据需要选择其他版本。
• container_name: 指定容器的名称，方便引用容器。
• ports: 映射 Frp 默认端口到主机。在这里，7000 端口用于 Frp 控制台，7500 端口用于 Frp 状态页面。
• restart: 配置容器的重启策略，确保 Frp 服务在容器退出时重新启动。
• volumes: 映射 Frp 配置文件 frps.ini 到主机，以确保配置在容器停止或删除后仍然保留在主机上。
• networks: 定义了一个外部网络 frp-net，以确保容器之间可以相互通信。

接下来，需要创建 Frp 的配置文件 frps.ini，并将其与 docker-compose.yml 文件放在同一目录下。

[common]
bind_port = 7000
vhost_http_port = 80
dashboard_port = 7500
dashboard_user = admin
dashboard_pwd = admin

# 添加需要进行端口映射的配置
[ssh]
type = tcp
local_ip = 127.0.0.1
local_port = 22
remote_port = 6000

[web]
type = http
local_ip = 127.0.0.1
local_port = 80
custom_domains = your-domain.com

包含了两个示例配置，一个用于 SSH 端口映射，另一个用于 HTTP 端口映射。需要根据实际需求进行相应的配置。

12.3 WireGuard

WireGuard 是一种快速、现代、安全的 VPN 协议，其简单性和性能优势使其成为一个受欢迎的选择。

version: '3'
services:
  wireguard:
    image: linuxserver/wireguard:latest
    container_name: wireguard
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    environment:
      - PUID=1000  # 替换为你的用户ID
      - PGID=1000  # 替换为你的组ID
      - TZ=UTC
    volumes:
      - ./config:/config
    ports:
      - "51820:51820/udp"
    restart: always

networks:
  default:
    external:
      name: wireguard-net

• image: 使用的 WireGuard 镜像。在这个例子中，使用的是 linuxserver/wireguard:latest。可以根据需要选择其他版本。
• container_name: 指定容器的名称，方便引用容器。
• cap_add: 启用 NET_ADMIN 和 SYS_MODULE 权限，以便容器可以配置网络和加载内核模块。
• environment: 设置环境变量，包括用户ID (PUID)、组ID (PGID) 和时区 (TZ)。这些环境变量可能需要根据的系统进行调整。
• volumes: 映射 WireGuard 配置目录到主机，以确保配置在容器停止或删除后仍然保留在主机上。
• ports: 映射 WireGuard 默认端口到主机。在这里，51820 端口用于 WireGuard VPN。
• restart: 配置容器的重启策略，确保 WireGuard 服务在容器退出时重新启动。
• networks: 定义了一个外部网络 wireguard-net，以确保容器之间可以相互通信。

WireGuard 是一种快速、现代、安全的 VPN 协议，其简单性和性能优势使其成为一个受欢迎的选择。下面是一个使用 Docker Compose 部署 WireGuard 的完整而详细的配置文件。

首先，需要创建一个名为 docker-compose.yml 的文件，并将以下内容添加到文件中：

yamlCopy codeversion: '3'

services:
  wireguard:
    image: linuxserver/wireguard:latest
    container_name: wireguard
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    environment:
      - PUID=1000  # 替换为的用户ID
      - PGID=1000  # 替换为的组ID
      - TZ=UTC
    volumes:
      - ./config:/config
    ports:
      - "51820:51820/udp"
    restart: always

networks:
  default:
    external:
      name: wireguard-net

这个 docker-compose.yml 文件定义了一个服务，名为 wireguard。以下是配置的解释：

• image: 使用的 WireGuard 镜像。在这个例子中，使用的是 linuxserver/wireguard:latest。可以根据需要选择其他版本。
• container_name: 指定容器的名称，方便引用容器。
• cap_add: 启用 NET_ADMIN 和 SYS_MODULE 权限，以便容器可以配置网络和加载内核模块。
• environment: 设置环境变量，包括用户ID (PUID)、组ID (PGID) 和时区 (TZ)。这些环境变量可能需要根据的系统进行调整。
• volumes: 映射 WireGuard 配置目录到主机，以确保配置在容器停止或删除后仍然保留在主机上。
• ports: 映射 WireGuard 默认端口到主机。在这里，51820 端口用于 WireGuard VPN。
• restart: 配置容器的重启策略，确保 WireGuard 服务在容器退出时重新启动。
• networks: 定义了一个外部网络 wireguard-net，以确保容器之间可以相互通信。

接下来，需要在 config 目录中创建 WireGuard 的配置文件和密钥。创建 config 目录并进入该目录：

mkdir config
cd config

使用以下命令生成 WireGuard 配置文件和密钥：

docker run -it --rm \
  -v $(pwd):/etc/wireguard \
  linuxserver/wireguard:latest \
  /app/newpeer.sh

按照提示输入信息，包括公钥、私钥、IPv4 地址等。这将生成配置文件 wg0.conf 和密钥文件。

最后，使用以下命令启动 WireGuard 服务：

docker-compose up -d

如果顺利，应该能够通过 WireGuard 客户端连接到的 WireGuard 服务器。确保了解所使用的镜像的文档以获取更多配置选项和最佳实践。

13. 在线文档

Onlyoffice

OnlyOffice 是一套开源的办公套件，具有文档编辑、协作和集成等功能。

version: '3'  
services:  
  onlyoffice:  
    image: onlyoffice/documentserver:latest  
    container_name: onlyoffice-server  
    restart: always  
    ports:  
      - "8080:80"  
      - "8443:443"  
    volumes:  
      - ./onlyoffice/data:/var/www/onlyoffice/Data  
      - ./onlyoffice/config:/var/lib/onlyoffice/config  
    environment:  
      - ALLOW_ANONYMOUS=1  
      - MAX_UPLOAD_SIZE=20M  
      - CERT_PEM=/var/lib/onlyoffice/config/cert.pem  
      - KEY_PEM=/var/lib/onlyoffice/config/key.pem

• services:: 指定了要部署的服务列表。
• onlyoffice:: 定义了一个名为onlyoffice的服务，该服务使用OnlyOffice文档服务器的镜像。
• image: onlyoffice/documentserver:latest: 指定要使用的OnlyOffice镜像名称和版本，这里使用的是最新版本。
• container_name: onlyoffice-server: 指定容器的名称，这里命名为“onlyoffice-server”。
• restart: always: 设置容器在退出后自动重启。
• ports:: 定义了容器的端口映射。这里将容器的80端口映射到主机的8080端口，将容器的443端口映射到主机的8443端口。
• volumes:: 定义了本地文件系统上的目录和容器内路径之间的挂载关系。这里将本地的“onlyoffice/data”目录挂载到容器内的“/var/www/onlyoffice/Data”路径，将本地的“onlyoffice/config”目录挂载到容器内的“/var/lib/onlyoffice/config”路径。
• environment:: 定义了环境变量及其对应的值。这里设置了允许匿名访问（ALLOW_ANONYMOUS=1）、最大上传大小（MAX_UPLOAD_SIZE=20M）、以及SSL证书和密钥的路径（CERT_PEM和KEY_PEM）。

14. 工具链

14.1 Portainer

Portainer 是一个开源的容器管理界面，用于简化 Docker 容器的部署和管理。

version: '3'

services:
  portainer:
    image: portainer/portainer-ce:latest
    command: --swarm
    ports:
      - "9000:9000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    deploy:
      placement:
        constraints:
          - node.role == manager

volumes:
  portainer_data:

portainer: 这是一个服务的定义，使用 Portainer 的官方 Docker 镜像 portainer/portainer-ce:latest。这个服务被设计用于在 Docker Swarm 上运行。

• command: --swarm: 这个选项告诉 Portainer 在 Swarm 模式下运行。
• ports: - "9000:9000": 这将容器的 9000 端口映射到主机的 9000 端口。你可以通过 http://localhost:9000 访问 Portainer Web 界面。
• volumes: - /var/run/docker.sock:/var/run/docker.sock - portainer_data:/data: 这些卷用于将 Docker 守护进程的 Unix 套接字映射到容器内，以便 Portainer 可以与 Docker 守护进程通信，并将 Portainer 数据持久化存储在名为 portainer_data 的卷中。
• deploy: 这是一个 Swarm 部署的配置块。
  • placement: 在这里，使用了一个约束，要求 Portainer 服务只能运行在 Swarm 中的 manager 节点上。

14.2 Weaveworks

Weave 是一个用于容器网络的开源项目，它提供了简单易用的网络解决方案，适用于 Docker 容器和 Kubernetes 等容器编排工具。

version: '3'
services:
  weave:
    image: weaveworks/weave:latest
    privileged: true
    network_mode: "host"
    environment:
      - WEAVER_DEBUG=1
    command: ["--local", "launch"]
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

定义了一个名为 weave 的服务，使用 Weave 的官方 Docker 镜像 weaveworks/weave:latest。

• privileged: true: 这允许容器获得对系统特权的访问，这在 Weave 中是必需的。
• network_mode: "host": 这将容器放置在主机网络命名空间中，允许 Weave 与主机网络进行交互。
• environment: - WEAVER_DEBUG=1: 这个环境变量用于启用 Weave 的调试模式。
• command: ["--local", "launch"]: 这是 Weave 启动命令的参数，指示 Weave 在本地节点上启动。
• volumes: - /var/run/docker.sock:/var/run/docker.sock: 这将容器内的 Docker 客户端与主机的 Docker 守护进程进行通信。

14.3 Vault

Vault 是 HashiCorp 公司提供的一个开源工具，用于安全地管理和保护敏感信息，如访问令牌、密码、数据库凭据等。Vault 通常与 Consul 结合使用，Consul 用于存储 Vault 的集群状态和配置信息。

version: '3'
services:
  consul:
    image: consul:latest
    container_name: consul
    command: "agent -dev -client=0.0.0.0"
    ports:
      - "8500:8500"
    networks:
      - vault_network

  vault:
    image: vault:latest
    container_name: vault
    environment:
      - VAULT_DEV_ROOT_TOKEN_ID=myroot
      - VAULT_ADDR=http://127.0.0.1:8200
    ports:
      - "8200:8200"
    networks:
      - vault_network
    depends_on:
      - consul
    cap_add:
      - IPC_LOCK
    entrypoint: ["vault", "server", "-dev-listen-address", "0.0.0.0:8200"]

networks:
  vault_network:
    driver: bridge

在这个配置文件中，定义了两个服务：consul 和 vault。

Consul 服务

• image: consul:latest: 使用 Consul 的官方 Docker 镜像。
• command: "agent -dev -client=0.0.0.0": 启动 Consul agent，使用开发模式，允许任意地址访问。
• ports: - "8500:8500": 将 Consul Web UI 端口映射到主机的 8500 端口。
• networks: - vault_network: 将 Consul 加入到名为 vault_network 的网络中。

Vault 服务

• image: vault:latest: 使用 Vault 的官方 Docker 镜像。
• environment: - VAULT_DEV_ROOT_TOKEN_ID=myroot - VAULT_ADDR=http://127.0.0.1:8200: 设置 Vault 的环境变量，包括开发模式的根令牌和地址。
• ports: - "8200:8200": 将 Vault API 端口映射到主机的 8200 端口。
• networks: - vault_network: 将 Vault 加入到名为 vault_network 的网络中。
• depends_on: - consul: 确保在启动 Vault 之前，Consul 已经启动。
• cap_add: - IPC_LOCK: 允许 Vault 使用 IPC_LOCK 权限。
• entrypoint: ["vault", "server", "-dev-listen-address", "0.0.0.0:8200"]: 设置 Vault 的启动命令。

15. API 网关和服务网格

15.1 Kong

Kong 是一个用于构建和管理 API 网关的开源工具。

version: '3'
services:
  kong-database:
    image: postgres:9.6
    container_name: kong-database
    environment:
      POSTGRES_DB: kong
      POSTGRES_USER: kong
      POSTGRES_PASSWORD: kong

  kong:
    image: kong:2.7.0
    container_name: kong
    depends_on:
      - kong-database
    environment:
      KONG_DATABASE: postgres
      KONG_PG_HOST: kong-database
      KONG_PG_USER: kong
      KONG_PG_PASSWORD: kong
      KONG_ADMIN_LISTEN: 0.0.0.0:8001
      KONG_PROXY_LISTEN: 0.0.0.0:8000

• kong-database 服务使用 PostgreSQL 镜像，用于存储 Kong 的配置信息。
• kong 服务使用 Kong 的官方 Docker 镜像，并依赖于 kong-database 服务。
• 在 kong 服务的环境变量中，配置了 Kong 使用的数据库类型、数据库连接信息、以及 API 网关的监听地址。

15.2 Istio

Istio 是一个开源的服务网格平台，用于连接、监视和保护微服务应用程序。

version: '3'
services:
  istio-control-plane:
    image: docker.io/istio/pilot:1.11.0
    container_name: istio-control-plane
    ports:
      - "15010:15010"
      - "15011:15011"
      - "15012:15012"
      - "8080:8080"
      - "8443:8443"
      - "15014:15014"
    command: ["istiod"]
    environment:
      - PILOT_CERT_PROVIDER=istiod
    volumes:
      - /var/run/secrets/tokens

  istio-ingressgateway:
    image: docker.io/istio/proxyv2:1.11.0
    container_name: istio-ingressgateway
    ports:
      - "15020:15020"
      - "15021:15021"
      - "80:80"
      - "443:443"
      - "15090:15090"
    environment:
      - PILOT_AGENT_ADDR=istio-control-plane:15012
      - PILOT_XDS_ADDR=istio-control-plane:15010
      - GATEWAY_CERT_FILE=/etc/certs/cert-chain.pem
      - GATEWAY_KEY_FILE=/etc/certs/key.pem
      - GATEWAY_SDS_ENABLED=false
      - SERVICE_NAME=istio-ingressgateway
      - DOWNSTREAM_TLS_CONTEXT=default

  istio-sidecar-injector:
    image: docker.io/istio/proxyv2:1.11.0
    container_name: istio-sidecar-injector
    entrypoint: /usr/local/bin/istio-iptables.sh
    ports:
      - "15001:15001"
      - "15006:15006"
    environment:
      - PILOT_AGENT_ADDR=istio-control-plane:15012
      - PILOT_XDS_ADDR=istio-control-plane:15010
      - CA_ADDR=istio-control-plane:15006
      - CA_PROVIDER=Citadel
      - CA_CERT_PATH=/etc/certs/cert-chain.pem
      - CA_KEY_PATH=/etc/certs/key.pem
    volumes:
      - /etc/certs

  bookinfo-app:
    image: docker.io/istio/examples-bookinfo-details-v1:1.11.0
    container_name: bookinfo-app
    ports:
      - "9080:9080"

• istio-control-plane 服务使用 Istio Pilot 镜像，用于 Istio 控制平面。
• istio-ingressgateway 服务使用 Istio ProxyV2 镜像，用于处理入口流量。
• istio-sidecar-injector 服务同样使用 Istio ProxyV2 镜像，用于注入 Envoy 代理到应用程序容器。
• bookinfo-app 服务使用 Istio 示例中的 Bookinfo 应用程序，用于演示 Istio 功能。

15.3 Linkerd

Linkerd 是一个用于构建和管理服务网格的开源工具。

version: '3'
services:
  linkerd:
    image: buoyantio/linkerd:stable-2.11.0
    container_name: linkerd
    ports:
      - "4191:4191"
      - "9990:9990"
    command: ["linkerd", "run"]

  linkerd-viz:
    image: buoyantio/linkerd-viz:stable-2.11.0
    container_name: linkerd-viz
    ports:
      - "8084:8084"
      - "8086:8086"
    environment:
      - LINKERD_VIZ_K8S_API_URL=http://linkerd:4191
      - LINKERD_VIZ_PUBLIC_PORT=8084
      - LINKERD_VIZ_RPC_PORT=8086

• services: 这是一个 Docker Compose 文件的主要部分，定义了需要运行的各个服务。
  • linkerd: 这是 Linkerd 控制平面和数据平面的服务。使用 buoyantio/linkerd:stable-2.11.0 镜像，监听 4191 端口用于控制平面通信，以及 9990 端口用于 Linkerd 控制台。command 字段指定在容器启动时运行的命令。
  • linkerd-viz: 这是 Linkerd Viz 的服务，用于可视化 Linkerd 的运行状态。使用 buoyantio/linkerd-viz:stable-2.11.0 镜像，监听 8084 端口提供可视化界面，以及 8086 端口用于 Linkerd Viz 的 RPC。
• image: 指定服务所使用的 Docker 镜像。
• container_name: 指定服务容器的名称。
• ports: 定义容器和主机之间的端口映射关系。
• command: 指定在容器启动时运行的命令。在这里，使用 Linkerd 的 linkerd run 命令。
• environment: 用于设置环境变量，这里用于配置 Linkerd Viz 的相关环境变量，包括 Linkerd 控制平面的地址和端口。

15.4 Traefik

Traefik 是一个用于反向代理和负载均衡的开源工具，通常用于为容器化的应用提供外部访问。

version: '3'
services:
  traefik:
    image: traefik:v2.5
    container_name: traefik
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
    ports:
      - "80:80"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

• traefik 服务使用了 Traefik 的官方 Docker 镜像，用于运行 Traefik 反向代理。
• command 字段指定了 Traefik 的启动参数，其中 --api.insecure=true 启用了 Traefik 的 API，--providers.docker=true 启用了 Docker 作为 Traefik 的后端服务提供者。
• ports 定义了容器和主机之间的端口映射关系，包括将主机的 80 端口映射到容器的 80 端口，以及将主机的 8080 端口映射到容器的 8080 端口。
• volumes 将主机的 Docker Socket 映射到容器内，以便 Traefik 可以监听 Docker 的事件并动态地更新配置。

16. 测试工具

16.1 JMeter

JMeter（Apache JMeter）是一个用于性能测试和负载测试的开源工具。

version: '3'
services:
  jmeter:
    image: justb4/jmeter:latest
    container_name: jmeter
    volumes:
      - ./jmeter:/jmeter
    command: -n -t /jmeter/test.jmx -l /jmeter/results.jtl

定义了一个名为 jmeter 的服务，使用 JMeter 的官方 Docker 镜像 justb4/jmeter:latest。

• volumes: - ./jmeter:/jmeter: 这将当前目录下的 jmeter 目录挂载到容器内，用于存放 JMeter 测试计划文件和测试结果文件。
• command: -n -t /jmeter/test.jmx -l /jmeter/results.jtl: 这是 JMeter 启动命令的参数，其中 -n 表示非 GUI 模式，-t 指定测试计划文件，-l 指定结果文件。

在 ./jmeter 目录下创建一个名为 test.jmx 的 JMeter 测试计划文件。这个文件可以使用 JMeter GUI 创建，也可以直接使用文本编辑器编写。

16.2 Locust

Locust 是一个用于执行负载测试的开源工具，它使用 Python 脚本来定义用户行为和测试逻辑。

version: '3'
services:
  locust:
    image: locustio/locust:latest
    container_name: locust
    command: -f /locust/locustfile.py --host http://target-service
    ports:
      - "8089:8089"
    volumes:
      - ./locust:/locust

定义了一个名为 locust 的服务，使用 Locust 的官方 Docker 镜像 locustio/locust:latest。

• command: -f /locust/locustfile.py --host http://target-service: 这是 Locust 启动命令的参数，其中 -f 指定 Locust 文件，--host 指定要测试的目标服务的地址。
• ports: - "8089:8089": 将 Locust Web 界面暴露到主机的 8089 端口。
• volumes: - ./locust:/locust: 将当前目录下的 locust 目录挂载到容器内，用于存放 Locust 脚本文件。

在 ./locust 目录下创建一个名为 locustfile.py 的 Locust 脚本文件。这个文件定义了用户行为和测试逻辑。

from locust import HttpUser, task, between

class MyUser(HttpUser):
    wait_time = between(1, 3)

    @task
    def my_task(self):
        self.client.get("/")

17. 反向代理和负载均衡服务

17.1 Nginx

Nginx 是一个高性能的开源 Web 服务器和反向代理服务器。

version: '3'
services:
  nginx:
    image: nginx:latest
    container_name: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx/conf:/etc/nginx/conf.d
      - ./nginx/html:/usr/share/nginx/html

定义了一个名为 nginx 的服务，使用 Nginx 的官方 Docker 镜像 nginx:latest。

• ports: - "80:80": 将主机的 80 端口映射到容器的 80 端口，使 Nginx 可以通过主机的 80 端口访问。
• volumes: - ./nginx/conf:/etc/nginx/conf.d - ./nginx/html:/usr/share/nginx/html: 这两个卷分别将主机的 nginx/conf 和 nginx/html 目录挂载到容器内的对应目录。这样可以实现自定义配置和提供自定义的静态内容。

在 ./nginx/conf 目录下创建一个名为 default.conf 的 Nginx 配置文件。

server {
    listen 80;
    server_name localhost;

    location / {
        root /usr/share/nginx/html;
        index index.html;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

这个配置文件定义了一个简单的 Nginx 服务器，监听主机的 80 端口，将请求映射到 /usr/share/nginx/html 目录下，并定义了错误页面的处理。

在 ./nginx/html 目录下创建一个名为 index.html 的静态 HTML 文件。可以根据需要编写 HTML 内容。

    
    
    
    


    
Welcome to My Nginx Server
    
This is a simple HTML page served by Nginx.

17.2 HAProxy

HAProxy（High Availability Proxy）是一个流行的开源负载均衡器和反向代理服务器。

version: '3'
services:
  haproxy:
    image: haproxy:latest
    container_name: haproxy
    ports:
      - "80:80"
    volumes:
      - ./haproxy:/usr/local/etc/haproxy
    networks:
      - webnet
    depends_on:
      - web1
      - web2

  web1:
    image: httpd:latest
    container_name: web1
    networks:
      - webnet

  web2:
    image: nginx:latest
    container_name: web2
    networks:
      - webnet

networks:
  webnet:

• image: haproxy:latest: 使用 HAProxy 官方 Docker 镜像。
• container_name: haproxy: 设置容器的名称为 haproxy。
• ports: - "80:80": 将主机的 80 端口映射到容器的 80 端口，允许通过主机的 80 端口访问 HAProxy。
• volumes: - ./haproxy:/usr/local/etc/haproxy: 将主机的 haproxy 目录挂载到容器内的 /usr/local/etc/haproxy 目录，用于存放 HAProxy 的配置文件。
• networks: - webnet: 将容器连接到名为 webnet 的自定义网络。
• depends_on: - web1 - web2: 表示 haproxy 服务依赖于 web1 和 web2 服务，确保在启动 haproxy 之前先启动这两个服务。

web1 服务和 web2 服务:

• image: httpd:latest 和 image: nginx:latest: 分别使用 Apache HTTP Server 和 Nginx 官方 Docker 镜像。
• container_name: web1 和 container_name: web2: 设置容器的名称为 web1 和 web2。
• networks: - webnet: 将这两个服务连接到名为 webnet 的自定义网络。
• 定义一个名为 webnet 的自定义网络，用于连接 haproxy、web1 和 web2 服务。

在 ./haproxy 目录下创建一个名为 haproxy.cfg 的 HAProxy 配置文件。

global
    log /dev/log local0
    log /dev/log local1 notice
    chroot /var/lib/haproxy
    stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners
    stats timeout 30s
    user haproxy
    group haproxy
    daemon

defaults
    log global
    mode http
    option httplog
    option dontlognull
    timeout connect 5000
    timeout client 50000
    timeout server 50000

frontend web
    bind *:80
    mode http
    default_backend app_servers

backend app_servers
    mode http
    balance roundrobin
    option httpchk HEAD / HTTP/1.1\r\nHost:localhost
    server web1 web1:80 check
    server web2 web2:80 check

配置文件定义了一个简单的 HAProxy 配置，监听主机的 80 端口，并将流量分发到两个后端服务器（web1 和 web2）。