安装asdf

1.下载 asdf

 git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.15.0

2.安装 asdf

# 在 ~/.bashrc 文件中加入以下内容： . "$HOME/.asdf/asdf.sh" . "$HOME/.asdf/completions/asdf.bash"

3.安装所需插件

asdf plugin add golang
asdf plugin add nodejs
asdf plugin add python
asdf plugin add php
asdf plugin add java

1. 检查插件列表
asdf plugin list

4.编程语言安装

1.Golang安装

# 检查支持的版本有哪些
asdf list-all golang

1. 这里选择1.23.4 
asdf install golang 1.23.4

1. 检查已安装版本
asdf list golang

1. 配置全局命令行工具（切换版本）
asdf global golang 1.23.4

1. 测试
go version

2.Nodejs安装

# 自动选择最新版，其他步骤同golang
asdf install nodejs latest

3.Python安装

# 这里注意安装python/php需要安装一些依赖库，ubuntu安装示例
sudo apt update && sudo apt install -y gcc pkg-config make \
 zlib1g-dev libssl-dev libbz2-dev libncurses-dev \
libffi-dev libreadline-dev libsqlite3-dev tk-dev liblzma-dev

1. 执行安装
asdf install python 3.13.1

#自带 pip
pip --version

4.PHP安装

# 在python依赖库基础上多了一些
sudo apt update && sudo apt install -y pkg-config build-essential \
 autoconf bison re2c libxml2-dev libsqlite3-dev libcurl4-openssl-dev\
 libgd-dev libonig-dev libpq-dev libzip-dev

1. 执行安装
asdf install php 8.1.31

1. 自带composer pear pecl
composer --version
pear version
pecl version

5.Java安装

# 推荐Oracle发行版
asdf install java oracle-21.0.5

1. 若需要频繁切换maven gradle 依然可以使用asdf安装
1. 我这里就直接使用apt安装了
sudo apt update && sudo apt install -y maven gradle

#检查
mvn --version
gradle --version

C/C++

# 上面已经安装过了
gcc version
c++ version

rust安装

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

1. 检查
rustc --version
cargo --version

Docker

在windows宿主机安装docker desktop，启用wsl2即可

1.MySQL

2.Redis

3.MongoDB

4.PostgreSQL

这里使用一个docker compose实现

 

networks:
  local_net:
    ipam:
      driver: default
      config:
        - subnet: 172.18.0.0/16

services:
  1. Nginx 作为网关
  nginx:
    image: nginx:latest
    container_name: nginx-gateway
    ports:
      - "80:80"
      1. - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/html:/usr/share/nginx/html
      - ./nginx/conf.d:/etc/nginx/conf.d
    restart: always
    networks:
      local_net:
        ipv4_address: 172.18.0.2

  1. MySQL 数据库
  mysql:
    image: mysql:8.4
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_DATABASE: mydb
      MYSQL_USER: myuser
      MYSQL_PASSWORD: mypassword
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    restart: always
    networks:
      local_net:
        ipv4_address: 172.18.0.3

  1. Redis 数据库
  redis:
    image: redis:latest
    container_name: redis-db
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    restart: always
    networks:
      local_net:
        ipv4_address: 172.18.0.4

  1. MongoDB 数据库
  mongodb:
    image: mongo:8.0
    container_name: mongodb-db
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: rootpassword
    ports:
      - "27017:27017"
    volumes:
      - mongodb-data:/data/db
    restart: always
    networks:
      local_net:
        ipv4_address: 172.18.0.5

  1. PostgreSQL 数据库
  postgresql:
    image: postgres:15
    container_name: postgresql-db
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgrespassword
      POSTGRES_DB: postgresdb
    ports:
      - "5432:5432"
    volumes:
      - postgresql-data:/var/lib/postgresql/data
    restart: always
    networks:
      local_net:
        ipv4_address: 172.18.0.6

volumes:
  mysql-data:
  redis-data:
  mongodb-data:
  postgresql-data:

为了构建一个全面的开发环境，除了你提到的数据库，以下是一些常用的软件和中间件：

1. 消息队列

docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:management
docker run -d --name kafka -p 9092:9092 -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092 -e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 bitnami/kafka

2. 缓存

docker run -d --name memcached -p 11211:11211 memcached

3. 搜索引擎

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:8.9.0
docker run -d --name kibana -p 5601:5601 --link elasticsearch:elasticsearch kibana:8.9.0

4. 监控与日志

docker run -d --name prometheus -p 9090:9090 prom/prometheus
docker run -d --name grafana -p 3000:3000 grafana/grafana
docker run -d --name loki -p 3100:3100 grafana/loki

5. 其他常用服务

# 对象存储
docker run -d --name minio -p 9000:9000 -p 9001:9001 minio/minio server /data --console-address ":9001"

1. API网关
docker run -d --name kong -p 8000:8000 -p 8001:8001 -p 8443:8443 -p 8444:8444 kong:3.3.0

1. 任务调度
docker run -d --name airflow -p 8080:8080 apache/airflow:2.6.2

6. 开发工具

# 代码质量检查
docker run -d --name sonarqube -p 9000:9000 sonarqube:9.9.1-community

1. 持续集成
docker run -d --name jenkins -p 8080:8080 -p 50000:50000 jenkins/jenkins:lts

7. 网络工具

# API测试
docker run -d --name postman -p 4000:4000 postman/newman

1. 网络模拟
docker run -d --name toxiproxy -p 8474:8474 shopify/toxiproxy

这些容器可以满足大多数开发场景的需求。建议使用 docker-compose来管理这些服务，方便统一启动和配置。

一、技术广度拓展：建议添加的核心组件

以下组件能帮助你掌握现代分布式系统开发中的核心中间件和技术：

1. 消息队列（RabbitMQ/Kafka）

• 价值：学习异步通信、事件驱动架构、分布式系统解耦
• Docker 配置示例：

  
  rabbitmq:
  image: rabbitmq:management
  container_name: rabbitmq-server
  ports:
  - "5672:5672"  # AMQP 协议端口
  - "15672:15672" # 管理界面
  networks:
  local_net:
    ipv4_address: 172.18.0.7

kafka: image: bitnami/kafka:latest container_name: kafka-server ports:

• “9092:9092” environment: KAFKA_CFG_LISTENERS: PLAINTEXT://:9092 KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092 KAFKA_CFG_ZOOKEEPER_CONNECT: zookeeper:2181 depends_on:
• zookeeper networks: local_net: ipv4_address: 172.18.0.8

zookeeper: image: bitnami/zookeeper:latest container_name: zookeeper-server ports:

• “2181:2181” networks: local_net: ipv4_address: 172.18.0.9

2. 分布式缓存（Redis 高级用法）

• 优化建议：你已配置 Redis，但可以扩展以下场景：
  • Redis Sentinel 高可用模式
  • Redis Streams 实现消息队列
  • RedisJSON 模块实践

3. API 网关（Kong/APISIX）

• 价值：学习微服务架构下的流量管理、插件开发
• Docker 配置示例：

  kong:
  image: kong:3.6
  container_name: kong-gateway
  environment:
  KONG_DATABASE: "postgres"
  KONG_PG_HOST: postgresql
  KONG_PG_USER: postgres
  KONG_PG_PASSWORD: postgrespassword
  ports:
  - "8000:8000"  # 代理端口
  - "8443:8443"  # SSL 代理
  - "8001:8001"  # Admin API
  depends_on:
  - postgresql
  networks:
  local_net:
    ipv4_address: 172.18.0.10

4. 监控三件套（Prometheus + Grafana + Loki）

• 价值：掌握可观测性体系建设
• Docker 配置示例：

  
  prometheus:
  image: prom/prometheus:latest
  volumes:
  - ./prometheus.yml:/etc/prometheus/prometheus.yml
  ports:
  - "9090:9090"
  networks:
  local_net:
    ipv4_address: 172.18.0.11

grafana: image: grafana/grafana:latest ports:

• “3000:3000” networks: local_net: ipv4_address: 172.18.0.12

loki: image: grafana/loki:latest ports:

• “3100:3100” networks: local_net: ipv4_address: 172.18.0.13

二、生产级实践模拟：关键优化建议

1. 网络配置优化

networks:
  local_net:
    driver: bridge
    ipam:
      config:
        - subnet: 172.18.0.0/24  # 缩小子网范围避免浪费

2. 服务健康检查

1. 以 MySQL 为例
mysql:
  healthcheck:
    test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
    interval: 5s
    timeout: 3s
    retries: 5

3. 资源限制

redis:
  deploy:
    resources:
      limits:
        cpus: '0.5'
        memory: 512M

4. 密钥管理

secrets:
  mysql_root_password:
    file: ./secrets/mysql_root_password.txt

services:
  mysql:
    environment:
      MYSQL_ROOT_PASSWORD_FILE: /run/secrets/mysql_root_password
    secrets:
      - mysql_root_password

三、技术栈精进路线建议

四、进阶实践建议

1. 场景化项目实践：

   • 用 Kafka 实现订单系统的最终一致性
   • 用 Kong 插件开发 JWT 认证模块
   • 使用 Prometheus 实现自定义业务指标监控

2. 破坏性测试：

   • 模拟网络分区（docker network disconnect）
   • 强制杀死容器观察恢复过程
   • 测试数据库主从切换场景

3. 基础设施即代码：

   • 将 docker-compose 迁移到 Terraform
   • 编写 Ansible Playbook 实现环境初始化

一、开发环境完整度提升

1. 搜索引擎 (Elasticsearch + Kibana)

elasticsearch:
  image: elasticsearch:8.13.0
  environment:
    discovery.type: single-node
    xpack.security.enabled: "false"
  ports:
    - "9200:9200"
  networks:
    local_net:
      ipv4_address: 172.18.0.14

kibana:
  image: kibana:8.13.0
  ports:
    - "5601:5601"
  depends_on:
    - elasticsearch
  networks:
    local_net:
      ipv4_address: 172.18.0.15

2. 对象存储 (MinIO)

minio:
  image: minio/minio:RELEASE.2024-05-23T05-35-35Z
  command: server /data --console-address ":9001"
  environment:
    MINIO_ROOT_USER: minioadmin
    MINIO_ROOT_PASSWORD: minioadmin
  ports:
    - "9000:9000"  # API 端口
    - "9001:9001"  # 控制台端口
  volumes:
    - minio-data:/data
  networks:
    local_net:
      ipv4_address: 172.18.0.16

3. 任务调度 (Airflow + Celery)

airflow:
  image: apache/airflow:2.9.0
  environment:
    AIRFLOW__CORE__EXECUTOR: CeleryExecutor
    AIRFLOW__DATABASE__SQL_ALCHEMY_CONN: postgresql+psycopg2://postgres:postgrespassword@postgresql/postgresdb
  ports:
    - "8080:8080"
  depends_on:
    - postgresql
    - redis
  networks:
    local_net:
      ipv4_address: 172.18.0.17

二、工程化能力训练

1. 代码质量检查 (SonarQube)

sonarqube:
  image: sonarqube:community
  ports:
    - "9000:9000"
  environment:
    SONAR_ES_BOOTSTRAP_CHECKS_DISABLE: "true"
  volumes:
    - sonarqube-data:/opt/sonarqube/data
    - sonarqube-extensions:/opt/sonarqube/extensions
  networks:
    local_net:
      ipv4_address: 172.18.0.18

2. 持续集成 (GitLab Runner + Jenkins)

gitlab-runner:
  image: gitlab/gitlab-runner:alpine
  volumes:
    - /var/run/docker.sock:/var/run/docker.sock
    - ./gitlab-runner-config:/etc/gitlab-runner
  networks:
    local_net:
      ipv4_address: 172.18.0.19

jenkins:
  image: jenkins/jenkins:lts-jdk17
  ports:
    - "8080:8080"
    - "50000:50000"
  volumes:
    - jenkins-data:/var/jenkins_home
  networks:
    local_net:
      ipv4_address: 172.18.0.20

3. API 测试 (Postman Newman + Swagger Editor)

swagger-editor:
  image: swaggerapi/swagger-editor
  ports:
    - "8081:8080"
  networks:
    local_net:
      ipv4_address: 172.18.0.21

三、网络模拟与混沌工程

1. 网络模拟工具 (toxiproxy)

toxiproxy:
  image: shopify/toxiproxy:2.8.0
  ports:
    - "8474:8474"  # 控制端口
    - "9002:9002"  # 被代理服务示例端口
  networks:
    local_net:
      ipv4_address: 172.18.0.22

2. 网络故障注入 (Comcast)

1. 模拟 100ms 延迟 + 10% 丢包 (需在宿主机执行)
docker run --rm -it --net container:nginx-gateway \
  tyhicks/comcast --latency 100 --packet-loss 10%

四、技术深度训练建议

五、环境整合建议

1. 分层架构：

   [网关层]      [服务层]          [数据层]            [支撑层]
   Nginx/Kong → 业务微服务    → MySQL/PostgreSQL     | CI/CD (Jenkins)
          ↘ 定时任务服务 → Redis/MongoDB        | 监控 (Prometheus)
          ↘ API 测试工具 → Elasticsearch/MinIO  | 日志 (Loki)

2. 学习路线：

   graph TD
   A[基础服务] --> B[分布式中间件]
   B --> C[可观测性体系]
   C --> D[混沌工程]
   D --> E[生产级最佳实践]

需要任何具体组件的详细配置示例或特定场景的演练方案，可以随时告诉我！这些工具的集成将帮助你构建一个媲美中小型企业生产环境的技术沙箱。

以下是针对你提到的工具链部署场景的服务器配置分析和集群规划建议：

一、单机部署场景分析（All-in-One）

1. 开发测试环境（单机）

• 推荐配置：
  • CPU：4 核（支持轻量级虚拟化）
  • 内存：8-16 GB（需同时运行 IDE 和容器）
  • 存储：100 GB SSD（代码 + 数据库 + 镜像存储）
  • 网络：千兆网卡
• 典型负载：

  - 数据库 (MySQL/PostgreSQL/MongoDB): 2-3 GB
  - Redis/Elasticsearch: 1-2 GB
  - Nginx/Kong: 0.5 GB
  - 应用服务 x3: 1 GB/个
  - 监控工具 (Prometheus+Grafana): 1 GB

2. 生产环境（单机 – 仅适用于极小规模）

• 推荐配置：
  • CPU：8 核（预留突发负载缓冲）
  • 内存：32 GB（数据库缓存优化）
  • 存储：500 GB NVMe SSD（RAID1 保障数据安全）
  • 网络：双千兆网卡（Bonding 模式）
• 资源分配原则：
  • 数据库独占 50% 内存
  • 中间件（Redis/ES）分配 30% 资源
  • 剩余资源用于应用服务

二、多节点集群规划（4C8G 服务器）

1. Docker Swarm 集群

• Swarm 特性：
  • Manager 节点推荐奇数个（Raft 共识）
  • 每个 Manager 需 2 GB 内存用于集群管理
  • 开发环境可复用 Manager 作为 Worker

2. Kubernetes 集群

• K8s 资源占用：
  • Control Plane 节点：需预留 1 CPU + 1.5 GB 内存/节点
  • Worker 节点：至少保留 0.5 CPU + 512 MB 内存给系统进程

三、典型中间件的集群部署建议

1. 数据库类

2. 基础设施类

四、成本优化建议

1. 开发测试环境：

   • 使用 Spot 实例（云环境）或 旧硬件复用
   • 启用资源超卖（CPU 超卖比 1:3，内存 1:1.5）

2. 生产环境：

   • 采用 混合部署策略（关键服务独占节点，次要服务混部）
   • 使用 垂直扩缩容（如数据库节点独立扩容）

五、架构选择决策树

是否需要高级调度策略？ 
  ├─ 否 → Docker Swarm（3-5 节点） 
  └─ 是 → Kubernetes（7+ 节点）
是否需要服务网格？ 
  ├─ 否 → Swarm + Traefik 
  └─ 是 → K8s + Istio
数据密集型？ 
  ├─ 是 → 独立存储集群（Ceph/MinIO 集群）
  └─ 否 → 本地存储卷

实际部署时建议从最小可用集群开始，通过监控数据（如 Prometheus 的节点负载指标）逐步调整规模。需要具体组件的部署清单可以进一步讨论！ 🛠️

你的观察非常准确！我在第三部分中提到的中间件集群部署建议，实际上指的是中间件 自身的高可用架构（如 Redis Sentinel、MySQL Group Replication 等），这些中间件的集群部署 可以独立于 Swarm/K8s 集群之外，也可以直接运行在编排平台之上。下面我会用更清晰的逻辑重新梳理这一部分：

重新梳理：中间件在集群中的两种部署模式

模式 1：中间件直接运行在编排集群内

适用场景：开发测试环境、中小型生产环境
特点：

• 中间件实例作为 Swarm Service 或 K8s StatefulSet 运行
• 依赖编排平台实现服务发现和负载均衡
  示例（以 Redis Sentinel 集群为例）：

1. Swarm 部署示例
docker service create --name redis-sentinel \
  --replicas 3 \
  --network local_net \
  redis:alpine redis-server --sentinel

1. K8s StatefulSet 片段
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis-sentinel
spec:
  serviceName: redis-sentinel
  replicas: 3
  template:
    spec:
      containers:
      - name: redis
        image: redis:alpine
        args: ["redis-server", "--sentinel"]

模式 2：中间件独立于编排集群

适用场景：大型生产环境、数据密集型服务
特点：

• 中间件使用专用物理机/虚拟机部署
• 与业务容器集群物理隔离，避免资源竞争
  架构示意图：

              +-----------------+
              | 业务容器集群     |
              | (Swarm/K8s)    |
              +-------+---------+
                      |
                      | 网络通信
                      v
  +-----------------+    +-----------------+
  | Redis 独立集群   |    | MySQL 独立集群  |
  | (6 节点 Sentinel)|    | (3 节点 Group   |
  +-----------------+    |   Replication)  |
                     +-----------------+

原第三部分解读（修正版）

我在原回答中提到的 “集群部署建议” 特指中间件自身的集群拓扑，与是否运行在 Swarm/K8s 无关。具体对应关系如下：

开发测试环境中间件部署

生产环境中间件部署

关键决策因素

需要为某个具体中间件（如 MongoDB Sharding 集群）设计部署方案时，可以进一步讨论！ 🧑💻