Windows Subsystem for Linux 2 (WSL2)为Windows开发者提供了完整的Linux内核和环境，结合Docker Desktop，可以实现Linux开发环境和Windows系统的完美融合。openEuler在WSL2环境下运行稳定，配合Docker Desktop可以获得流畅的容器化开发体验。

本文将介绍在openEuler WSL2环境下，如何使用Docker Desktop进行容器化开发，包括环境配置、实际应用容器化、多容器编排、以及常见问题解决。相比在物理服务器上部署Kubernetes集群，这种方案更适合本地开发和测试，也是大多数开发者的实际使用场景。

# 在openEuler WSL2中执行
docker --version
# Docker version 24.0.x

docker info

# 测试运行容器
docker run hello-world

# 查看运行状态
docker ps

# 预期输出示例：
# CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

在Docker Desktop中配置镜像加速：

// Settings → Docker Engine
{
  "registry-mirrors": [
    "https://mirror.ccs.tencentyun.com",
    "https://docker.mirrors.ustc.edu.cn"
  ],
  "builder": {
    "gc": {
      "defaultKeepStorage": "20GB",
      "enabled": true
    }
  }
}

三、实战案例：Python Flask应用容器化

# 创建项目目录
mkdir -p ~/projects/flask-docker-app
cd ~/projects/flask-docker-app

# 创建应用代码
cat > app.py << 'EOF'
from flask import Flask, jsonify
import socket
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return jsonify({
        'message': 'Hello from openEuler WSL2!',
        'hostname': socket.gethostname(),
        'platform': os.uname().sysname
    })

@app.route('/health')
def health():
    return jsonify({'status': 'healthy'}), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
EOF

# 创建依赖文件
cat > requirements.txt << 'EOF'
Flask==3.0.0
gunicorn==21.2.0
EOF

cat > Dockerfile << 'EOF'
FROM python:3.11-slim

WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY app.py .

# 暴露端口
EXPOSE 5000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:5000/health')" || exit 1

# 使用gunicorn运行
CMD ["gunicorn", "-b", "0.0.0.0:5000", "-w", "2", "app:app"]
EOF

# 构建镜像
docker build -t flask-app:1.0 .

# 查看构建的镜像
docker images | grep flask-app

# 运行容器
docker run -d \
  --name myflask \
  -p 5000:5000 \
  flask-app:1.0

# 查看容器状态
docker ps

# 测试应用
curl http://localhost:5000

# 查看日志
docker logs myflask

# 进入容器
docker exec -it myflask bash

# 查看完整输出示例
docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"

# 创建项目目录
mkdir -p ~/projects/flask-postgres
cd ~/projects/flask-postgres

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      DATABASE_URL: postgresql://user:password@db:5432/mydb
    depends_on:
      db:
        condition: service_healthy
    restart: always

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres_data:

from flask import Flask, jsonify
import psycopg2
import os

app = Flask(__name__)

def get_db_connection():
    conn = psycopg2.connect(os.environ['DATABASE_URL'])
    return conn

@app.route('/')
def index():
    try:
        conn = get_db_connection()
        cur = conn.cursor()
        cur.execute('SELECT version();')
        db_version = cur.fetchone()[0]
        cur.close()
        conn.close()
        
        return jsonify({
            'status': 'connected',
            'database_version': db_version
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/health')
def health():
    return jsonify({'status': 'healthy'}), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Flask==3.0.0
psycopg2-binary==2.9.9
gunicorn==21.2.0

# 启动所有服务
docker-compose up -d

# 查看状态
docker-compose ps

# 查看日志
docker-compose logs -f

# 测试
curl http://localhost:5000

# 停止服务
docker-compose down

version: '3.8'

services:
  dev:
    image: python:3.11
    working_dir: /workspace
    volumes:
      - .:/workspace
      - pip_cache:/root/.cache/pip
    ports:
      - "5000:5000"
      - "8888:8888"  # Jupyter
    command: bash -c "pip install -r requirements.txt && python app.py"
    stdin_open: true
    tty: true

volumes:
  pip_cache:

# VS Code中安装扩展：
# - Remote - Containers
# - Docker

# 在容器中开发：
# 1. 右键点击运行中的容器
# 2. 选择 "Attach Visual Studio Code"
# 3. 在容器内直接编辑代码

services:
  app:
    volumes:
      # 绑定挂载（开发）
      - ./app:/app
      - ./config:/etc/app/config:ro
      
      # 命名卷（数据持久化）
      - app_data:/app/data
      - cache:/app/cache

volumes:
  app_data:
    driver: local
  cache:
    driver: local

# 启动Redis
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v redis_data:/data \
  redis:alpine redis-server --appendonly yes

# 测试连接
docker exec -it redis redis-cli ping
# PONG

# 使用Redis
docker exec -it redis redis-cli
> SET mykey "Hello WSL2"
> GET mykey

# 启动MySQL
docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -e MYSQL_DATABASE=testdb \
  -v mysql_data:/var/lib/mysql \
  mysql:8.0

# 连接数据库
docker exec -it mysql mysql -uroot -prootpass

# 或使用客户端
mysql -h 127.0.0.1 -P 3306 -uroot -prootpass

# 创建网站目录
mkdir -p ~/projects/mynginx/html
cd ~/projects/mynginx

# 创建首页
cat > html/index.html << 'EOF'
<!DOCTYPE html>
<html>
<head>
    <title>openEuler WSL2 + Docker</title>
</head>
<body>
    <h1>Hello from openEuler WSL2!</h1>
    <p>Running in Docker container</p>
</body>
</html>
EOF

# 运行Nginx
docker run -d \
  --name mynginx \
  -p 8080:80 \
  -v $(pwd)/html:/usr/share/nginx/html:ro \
  nginx:alpine

# 访问
curl http://localhost:8080
# 或在Windows浏览器打开：http://localhost:8080

# C:\Users\<YourUsername>\.wslconfig

[wsl2]
memory=8GB
processors=4
swap=2GB
localhostForwarding=true

# 1. 使用WSL2文件系统（更快）
cd ~/projects  # 在WSL2内
# 不要使用 /mnt/c/Users/...（Windows文件系统，较慢）

# 2. 清理未使用的容器和镜像
docker system prune -a

# 3. 查看磁盘使用
docker system df

# 4. 清理构建缓存
docker builder prune

# 检查Docker Desktop是否运行
# 在Windows任务栏查看Docker图标

# 重启Docker Desktop
# 右键点击Docker图标 → Restart

# 检查WSL2集成
# Docker Desktop → Settings → Resources → WSL Integration

# 测试容器网络
docker run --rm alpine ping -c 4 baidu.com

# 检查端口映射
docker port <container_name>

# 检查容器IP
docker inspect <container_name> | grep IPAddress

# WSL2中的文件权限
# 确保文件在WSL2文件系统中（~/）
# 而不是Windows挂载点（/mnt/c/）

# 修复权限
chmod +x script.sh
chown -R $USER:$USER .

# 使用.env文件
cat > .env << 'EOF'
DATABASE_URL=postgresql://user:pass@db:5432/mydb
REDIS_URL=redis://redis:6379/0
SECRET_KEY=your-secret-key
DEBUG=False
EOF

# docker-compose.yml中使用
services:
  app:
    env_file:
      - .env

# 开发环境
docker-compose -f docker-compose.yml -f docker-compose.dev.yml up

# 生产环境
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up

# GitHub Actions示例
name: Docker Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build Docker image
        run: docker build -t myapp:${{ github.sha }} .
      - name: Push to registry
        run: |
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
          docker push myapp:${{ github.sha }}

通过本文的实践，我们在openEuler WSL2环境下完成了：

对于生产环境的Kubernetes部署，建议使用云服务器或物理服务器。WSL2方案更适合开发者的日常工作，提供了便捷的容器化开发体验。

：本文为原创实践文章，所有操作均在openEuler WSL2 + Docker Desktop环境中验证。

openEuler WSL2容器化开发实战：Docker Desktop集成与应用部署

编程语言

在openEuler WSL2环境下使用Docker Desktop进行容器化开发，包括环境配置、Flask应用容器化、Docker Compose多容器编排等实战案例。详细介绍WSL2特有优化技巧和常见问题解决方案，适合本地开发测试环境搭建，实现Windows与Linux完美融合的开发体验。

云服务器

容器编排

文件系统

SQL数据库

Kubernetes

服务器

数据库

Windows

容器

Docker

Linux

11.11畅享AI算力 云启新增长

tencentdb-catalog

4核4G3M云服务器 新用户低至38元/年！

云数据库采购特惠，高性能、高可靠、高安全，超值优惠等你享！


文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

openEuler WSL2容器化开发实战：Docker Desktop集成与应用部署

openEuler WSL2容器化开发实战：Docker Desktop集成与应用部署

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐