# 1. 卸載舊版本（如果存在）
sudo apt-get remove docker docker-engine docker.io containerd runc

# 2. 更新 apt 包索引
sudo apt-get update

# 3. 安裝依賴包
sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 4. 添加 Docker 官方 GPG 密鑰
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 5. 設(shè)置穩(wěn)定版?zhèn)}庫
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 6. 更新 apt 包索引
sudo apt-get update

# 7. 安裝 Docker Engine
sudo apt-get install docker-ce docker-ce-cli containerd.io

# 8. 驗證安裝是否成功
sudo docker --version

# 9. 啟動 Docker 服務(wù)
sudo systemctl start docker
sudo systemctl enable docker

# 10. 測試運行 Hello World
sudo docker run hello-world

# 1. 卸載舊版本
sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

# 2. 安裝必要的包
sudo yum install -y yum-utils

# 3. 設(shè)置倉庫
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

# 4. 安裝 Docker Engine
sudo yum install docker-ce docker-ce-cli containerd.io

# 5. 啟動 Docker
sudo systemctl start docker
sudo systemctl enable docker

# 6. 驗證安裝
sudo docker --version
sudo docker run hello-world

# 創(chuàng)建 docker 用戶組（如果不存在）
sudo groupadd docker

# 將當(dāng)前用戶添加到 docker 組
sudo usermod -aG docker $USER

# 重新登錄或使用以下命令立即生效
newgrp docker

# 驗證非 root 用戶是否能運行 Docker 命令
docker run hello-world

# 下載最新版本的 Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.17.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 賦予執(zhí)行權(quán)限
sudo chmod +x /usr/local/bin/docker-compose

# 創(chuàng)建軟鏈接（如果需要）
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

# 驗證安裝
docker-compose --version

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>docker-demo</artifactId>
    <version>1.0.0</version>
    <name>docker-demo</name>
    <description>Spring Boot Docker Demo Project</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

docker-demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── dockerdemo/
│   │   │               ├── DockerDemoApplication.java
│   │   │               ├── controller/
│   │   │               │   └── HelloController.java
│   │   │               └── service/
│   │ │                   └── HelloService.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── static/
│   └── test/
├── Dockerfile
├── docker-compose.yml
└── pom.xml

package com.example.dockerdemo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/api")
public class HelloController {
    @GetMapping("/hello")
    public Map<String, Object> hello() {
        Map<String, Object> response = new HashMap<>();
        response.put("message", "Hello from Docker!");
        response.put("timestamp", LocalDateTime.now().toString());
        response.put("status", "success");
        return response;
    }
    @GetMapping("/health")
    public Map<String, Object> health() {
        Map<String, Object> response = new HashMap<>();
        response.put("status", "UP");
        response.put("service", "docker-demo");
        response.put("timestamp", System.currentTimeMillis());
        return response;
    }
}

# 應(yīng)用配置
server.port=8080
server.servlet.context-path=/
# 應(yīng)用信息
spring.application.name=docker-demo
# Actuator 配置
management.endpoints.web.exposure.include=health,info,metrics
management.endpoint.health.show-details=always
# 日志配置
logging.level.com.example.dockerdemo=DEBUG
logging.file.name=/var/log/docker-demo/app.log

# 進入項目根目錄
cd docker-demo

# 使用 Maven 打包項目
mvn clean package

# 或者使用 Maven Wrapper（如果項目中有 mvnw）
./mvnw clean package

# 打包成功后，在 target 目錄下會生成 JAR 文件
# docker-demo-1.0.0.jar

# 第一階段：構(gòu)建階段
# 使用官方 Maven 鏡像作為構(gòu)建環(huán)境
FROM maven:3.8.4-openjdk-11-slim AS builder

# 設(shè)置工作目錄
WORKDIR /app

# 復(fù)制 pom.xml 和源代碼
COPY pom.xml .
COPY src ./src

# 下載依賴（利用 Docker 緩存層，如果 pom.xml 不變則不重新下載）
RUN mvn dependency:go-offline -B

# 構(gòu)建應(yīng)用（跳過測試以加快構(gòu)建速度）
RUN mvn clean package -DskipTests

# 第二階段：運行階段
# 使用更小的 JRE 鏡像作為運行環(huán)境
FROM openjdk:11-jre-slim

# 設(shè)置元數(shù)據(jù)標(biāo)簽（可選）
LABEL maintainer="your-email@example.com"
LABEL version="1.0"
LABEL description="Spring Boot application in Docker"

# 設(shè)置時區(qū)（根據(jù)需求調(diào)整）
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

# 創(chuàng)建一個非 root 用戶運行應(yīng)用（安全最佳實踐）
RUN groupadd -r spring && useradd -r -g spring spring
USER spring

# 設(shè)置工作目錄
WORKDIR /app

# 從構(gòu)建階段復(fù)制構(gòu)建好的 JAR 文件
COPY --from=builder /app/target/docker-demo-*.jar app.jar

# 創(chuàng)建日志目錄并設(shè)置權(quán)限
RUN mkdir -p /var/log/docker-demo && \
    chown -R spring:spring /var/log/docker-demo

# 暴露應(yīng)用端口
EXPOSE 8080

# 設(shè)置 JVM 參數(shù)（根據(jù)實際情況調(diào)整）
ENV JAVA_OPTS="-Xms256m -Xmx512m -XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/docker-demo/heapdump.hprof"

# 啟動應(yīng)用
# 使用 exec 形式啟動，確保 Java 進程成為 PID 1，能正確處理信號
ENTRYPOINT exec java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar app.jar

# 健康檢查指令
HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
  CMD curl -f http://localhost:8080/api/health || exit 1

# 忽略所有以 . 開頭的文件
.*
# 忽略 IDE 配置文件
.vscode/
.idea/
*.iml
# 忽略構(gòu)建輸出
target/
build/
out/
# 忽略日志文件
*.log
logs/
# 忽略臨時文件
*.tmp
*.temp
tmp/
temp/
# 忽略 Git 相關(guān)
.git/
.gitignore
# 忽略 Docker 相關(guān)
Dockerfile*
docker-compose*
.dockerignore
# 忽略文檔
*.md
README

# 進入項目根目錄（確保 Dockerfile 在此目錄）
cd /path/to/docker-demo

# 構(gòu)建鏡像
# -t: 給鏡像打標(biāo)簽（名稱:版本）
# .: 構(gòu)建上下文路徑（當(dāng)前目錄）
docker build -t docker-demo:1.0.0 .

# 查看構(gòu)建過程輸出
# 可以看到每一層的構(gòu)建情況

# 1. 驗證 Dockerfile 語法
# 可以使用 docker build --dry-run 驗證語法（需要 buildx）
docker buildx build --dry-run .

# 2. 實際構(gòu)建鏡像（詳細輸出）
docker build -t docker-demo:1.0.0 --progress=plain .

# 3. 查看構(gòu)建的鏡像
docker images

# 輸出示例：
# REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
# docker-demo   1.0.0     abc123def456   2 minutes ago    215MB

# 1. 使用緩存加速構(gòu)建
# 如果依賴沒有變化，Docker 會使用緩存
docker build -t docker-demo:1.0.0 .

# 2. 不使用緩存（強制重新構(gòu)建所有層）
docker build -t docker-demo:1.0.0 --no-cache .

# 3. 指定目標(biāo)構(gòu)建階段
# 多階段構(gòu)建時，可以指定只構(gòu)建到某個階段
docker build -t docker-demo:builder --target builder .

# 4. 清理構(gòu)建緩存
docker builder prune

# 5. 查看鏡像構(gòu)建歷史
docker history docker-demo:1.0.0

# 給鏡像添加多個標(biāo)簽
docker build -t docker-demo:1.0.0 -t docker-demo:latest .

# 給現(xiàn)有鏡像添加新標(biāo)簽
docker tag docker-demo:1.0.0 docker-demo:stable

# 查看所有鏡像
docker images

# 刪除鏡像
docker rmi docker-demo:1.0.0

# 強制刪除鏡像（即使有容器使用）
docker rmi -f docker-demo:1.0.0

# 清理所有未使用的鏡像
docker image prune -a

# 最基本的方式運行容器
docker run docker-demo:1.0.0

# 但這會占用終端，且容器停止后會自動刪除

# 完整的容器運行命令
docker run -d \
  --name docker-demo-app \
  -p 8080:8080 \
  -e "SPRING_PROFILES_ACTIVE=prod" \
  -v /path/to/logs:/var/log/docker-demo \
  --restart unless-stopped \
  --memory=512m \
  --cpus="1.0" \
  --health-cmd="curl -f http://localhost:8080/api/health || exit 1" \
  --health-interval=30s \
  --health-timeout=3s \
  --health-retries=3 \
  docker-demo:1.0.0

# 查看運行中的容器
docker ps

# 查看所有容器（包括停止的）
docker ps -a

# 查看容器日志
docker logs docker-demo-app

# 實時查看日志
docker logs -f docker-demo-app

# 查看最后 N 行日志
docker logs --tail 100 docker-demo-app

# 查看容器資源使用情況
docker stats docker-demo-app

# 進入容器內(nèi)部（交互式 shell）
docker exec -it docker-demo-app /bin/bash

# 在容器內(nèi)執(zhí)行單個命令
docker exec docker-demo-app ls -la /app

# 停止容器
docker stop docker-demo-app

# 啟動已停止的容器
docker start docker-demo-app

# 重啟容器
docker restart docker-demo-app

# 刪除容器（必須先停止）
docker rm docker-demo-app

# 強制刪除運行中的容器
docker rm -f docker-demo-app

# 查看容器詳細信息
docker inspect docker-demo-app

# 查看容器端口映射
docker port docker-demo-app

# 復(fù)制文件到容器
docker cp localfile.txt docker-demo-app:/app/

# 從容器復(fù)制文件
docker cp docker-demo-app:/app/logs/app.log ./

# 創(chuàng)建自定義網(wǎng)絡(luò)（推薦）
docker network create app-network

# 查看網(wǎng)絡(luò)列表
docker network ls

# 在自定義網(wǎng)絡(luò)中運行容器
docker run -d \
  --name docker-demo-app \
  --network app-network \
  docker-demo:1.0.0

# 查看網(wǎng)絡(luò)詳情
docker network inspect app-network

# 連接容器到網(wǎng)絡(luò)
docker network connect app-network docker-demo-app

# 斷開容器與網(wǎng)絡(luò)的連接
docker network disconnect app-network docker-demo-app

# 刪除網(wǎng)絡(luò)
docker network rm app-network

# 1. 使用綁定掛載（bind mount）
docker run -d \
  -v /host/path/logs:/var/log/docker-demo \
  docker-demo:1.0.0

# 2. 使用 Docker 卷（volume）
# 創(chuàng)建卷
docker volume create app-logs

# 使用卷
docker run -d \
  -v app-logs:/var/log/docker-demo \
  docker-demo:1.0.0

# 查看卷列表
docker volume ls

# 查看卷詳情
docker volume inspect app-logs

# 清理未使用的卷
docker volume prune

# 3. 使用臨時文件系統(tǒng)（tmpfs）
docker run -d \
  --tmpfs /tmp \
  docker-demo:1.0.0

version: '3.8'
# 定義網(wǎng)絡(luò)（所有服務(wù)共享）
networks:
  app-network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/16
# 定義卷
volumes:
  app-logs:
    driver: local
  mysql-data:
    driver: local
# 定義服務(wù)
services:
  # Spring Boot 應(yīng)用服務(wù)
  app:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        - BUILD_VERSION=${BUILD_VERSION:-1.0.0}
    image: docker-demo:${BUILD_VERSION:-1.0.0}
    container_name: docker-demo-app
    restart: unless-stopped
    ports:
      - "8080:8080"
      - "8081:8081"  # 管理端口（如果需要）
    environment:
      - SPRING_PROFILES_ACTIVE=${PROFILE:-dev}
      - JAVA_OPTS=${JAVA_OPTS:--Xms256m -Xmx512m}
      - DB_HOST=mysql
      - DB_PORT=3306
      - DB_NAME=docker_demo
      - DB_USER=${DB_USER:-root}
      - DB_PASSWORD=${DB_PASSWORD:-password}
    volumes:
      - app-logs:/var/log/docker-demo
      - ./config:/app/config:ro  # 只讀掛載配置文件
    networks:
      - app-network
    depends_on:
      mysql:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '1.0'
        reservations:
          memory: 256M
          cpus: '0.5'
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    # 開發(fā)模式配置（覆蓋默認(rèn)）
    profiles: ["dev"]
    ports:
      - "8080:8080"
      - "5005:5005"  # 遠程調(diào)試端口
    environment:
      - JAVA_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -Xms256m -Xmx512m
  # MySQL 數(shù)據(jù)庫服務(wù)
  mysql:
    image: mysql:8.0
    container_name: docker-demo-mysql
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=${DB_PASSWORD:-password}
      - MYSQL_DATABASE=docker_demo
      - MYSQL_USER=${DB_USER:-appuser}
      - MYSQL_PASSWORD=${DB_PASSWORD:-password}
    volumes:
      - mysql-data:/var/lib/mysql
      - ./mysql/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
      - ./mysql/my.cnf:/etc/mysql/conf.d/my.cnf:ro
    networks:
      - app-network
    ports:
      - "3306:3306"
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p${MYSQL_ROOT_PASSWORD}"]
      interval: 10s
      timeout: 5s
      retries: 5
    command: 
      - --default-authentication-plugin=mysql_native_password
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
  # Redis 緩存服務(wù)
  redis:
    image: redis:7-alpine
    container_name: docker-demo-redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD:-redispass}
    healthcheck:
      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
      interval: 10s
      timeout: 3s
      retries: 3
  # Nginx 反向代理
  nginx:
    image: nginx:1.21-alpine
    container_name: docker-demo-nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
      - ./nginx/logs:/var/log/nginx
    networks:
      - app-network
    depends_on:
      - app
    healthcheck:
      test: ["CMD", "nginx", "-t"]
      interval: 30s
      timeout: 10s
      retries: 3
  # 監(jiān)控服務(wù)（Prometheus + Grafana）
  monitoring:
    image: prom/prometheus:latest
    container_name: docker-demo-prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus-data:/prometheus
    networks:
      - app-network
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--storage.tsdb.retention.time=200h'
      - '--web.enable-lifecycle'
  grafana:
    image: grafana/grafana:latest
    container_name: docker-demo-grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:-admin}
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning:ro
    networks:
      - app-network
    depends_on:
      - monitoring

# 應(yīng)用配置
BUILD_VERSION=1.0.0
PROFILE=prod
JAVA_OPTS=-Xms256m -Xmx512m
# 數(shù)據(jù)庫配置
DB_USER=appuser
DB_PASSWORD=StrongPassword123!
DB_NAME=docker_demo
# Redis 配置
REDIS_PASSWORD=RedisPass123!
# Grafana 配置
GRAFANA_PASSWORD=GrafanaAdmin123!

# 1. 構(gòu)建并啟動所有服務(wù)（后臺運行）
docker-compose up -d

# 2. 構(gòu)建鏡像（不啟動）
docker-compose build

# 3. 啟動已存在的服務(wù)
docker-compose start

# 4. 停止所有服務(wù)
docker-compose stop

# 5. 停止并刪除所有容器、網(wǎng)絡(luò)
docker-compose down

# 6. 停止并刪除所有容器、網(wǎng)絡(luò)、卷
docker-compose down -v

# 7. 查看服務(wù)狀態(tài)
docker-compose ps

# 8. 查看服務(wù)日志
docker-compose logs

# 9. 查看特定服務(wù)日志
docker-compose logs app

# 10. 實時查看日志
docker-compose logs -f app

# 11. 進入容器
docker-compose exec app /bin/bash

# 12. 在服務(wù)上執(zhí)行命令
docker-compose exec app ls -la

# 13. 重啟服務(wù)
docker-compose restart app

# 14. 擴展服務(wù)實例數(shù)
docker-compose up -d --scale app=3

# 15. 拉取服務(wù)鏡像
docker-compose pull

# 16. 查看服務(wù)配置
docker-compose config

# 17. 暫停服務(wù)
docker-compose pause app

# 18. 恢復(fù)暫停的服務(wù)
docker-compose unpause app

# 19. 使用特定環(huán)境文件
docker-compose --env-file .env.production up -d

# 20. 使用特定配置文件
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# 21. 只啟動部分服務(wù)
docker-compose up -d app mysql

# 22. 重新構(gòu)建服務(wù)
docker-compose up -d --build app

# 23. 清理未使用的資源
docker-compose down --rmi local

version: '3.8'
services:
  app:
    ports:
      - "8080:8080"
      - "5005:5005"
    environment:
      - SPRING_PROFILES_ACTIVE=dev
      - JAVA_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -Xms256m -Xmx512m
    volumes:
      - ./src:/app/src

version: '3.8'
services:
  app:
    restart: always
    deploy:
      resources:
        limits:
          memory: 1g
          cpus: '2.0'
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - JAVA_OPTS=-Xms512m -Xmx1024m -XX:+UseG1GC

# 1. 使用非 root 用戶運行容器
# 在 Dockerfile 中已設(shè)置
USER spring

# 2. 掃描鏡像安全漏洞
docker scan docker-demo:1.0.0

# 3. 使用內(nèi)容信任
export DOCKER_CONTENT_TRUST=1
docker build -t docker-demo:1.0.0 .

# 4. 限制容器能力
docker run -d \
  --cap-drop ALL \
  --cap-add NET_BIND_SERVICE \
  docker-demo:1.0.0

# 5. 設(shè)置只讀根文件系統(tǒng)
docker run -d \
  --read-only \
  --tmpfs /tmp \
  -v app-logs:/var/log/docker-demo \
  docker-demo:1.0.0

# docker-compose.yml 中的日志配置
logging:
  driver: "json-file"
  options:
    max-size: "10m"
    max-file: "3"
    compress: "true"
    labels: "production"
    env: "os,customer"

# 查看日志驅(qū)動
docker info --format '{{.LoggingDriver}}'

# 使用日志驅(qū)動
docker run -d \
  --log-driver json-file \
  --log-opt max-size=10m \
  --log-opt max-file=3 \
  docker-demo:1.0.0

# 使用 syslog 驅(qū)動
docker run -d \
  --log-driver syslog \
  --log-opt syslog-address=udp://syslog-server:514 \
  docker-demo:1.0.0

# 設(shè)置資源限制
docker run -d \
  --memory="512m" \
  --memory-swap="1g" \
  --cpus="1.5" \
  --cpu-shares="1024" \
  --blkio-weight="500" \
  docker-demo:1.0.0

# 查看容器資源使用
docker stats docker-demo-app

# 設(shè)置容器重啟策略
docker run -d \
  --restart always \		# 總是重啟
  --restart on-failure \	# 失敗時重啟
  --restart unless-stopped \	# 除非手動停止，否則重啟
  docker-demo:1.0.0

# 登錄 Docker Hub
docker login
# 給鏡像打標(biāo)簽（用于推送到倉庫）
docker tag docker-demo:1.0.0 yourusername/docker-demo:1.0.0
docker tag docker-demo:1.0.0 yourusername/docker-demo:latest
# 推送到 Docker Hub
docker push yourusername/docker-demo:1.0.0
docker push yourusername/docker-demo:latest
# 從倉庫拉取鏡像
docker pull yourusername/docker-demo:1.0.0
# 使用私有倉庫
docker tag docker-demo:1.0.0 registry.example.com/yourproject/docker-demo:1.0.0
docker push registry.example.com/yourproject/docker-demo:1.0.0
# 配置私有倉庫（非安全）
docker run -d \
  -p 5000:5000 \
  --name registry \
  registry:2
# 推送鏡像到私有倉庫
docker tag docker-demo:1.0.0 localhost:5000/docker-demo:1.0.0
docker push localhost:5000/docker-demo:1.0.0

# 備份容器數(shù)據(jù)
docker run --rm \
  --volumes-from docker-demo-app \
  -v $(pwd):/backup \
  ubuntu tar czf /backup/app-data-$(date +%Y%m%d).tar.gz /var/log/docker-demo

# 備份 Docker 卷
docker run --rm \
  -v app-logs:/data \
  -v $(pwd):/backup \
  ubuntu tar czf /backup/app-logs-$(date +%Y%m%d).tar.gz /data

# 導(dǎo)出容器
docker export docker-demo-app > docker-demo-container.tar

# 導(dǎo)入容器
cat docker-demo-container.tar | docker import - docker-demo:imported

# 保存鏡像為文件
docker save -o docker-demo-1.0.0.tar docker-demo:1.0.0

# 從文件加載鏡像
docker load -i docker-demo-1.0.0.tar

# 創(chuàng)建數(shù)據(jù)卷容器（用于數(shù)據(jù)共享）
docker create -v /var/log/docker-demo \
  --name app-data \
  busybox /bin/true

# 使用數(shù)據(jù)卷容器
docker run -d \
  --volumes-from app-data \
  docker-demo:1.0.0

# 解決方案：使用構(gòu)建緩存和鏡像加速器

# 1. 配置 Docker 鏡像加速器
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://mirror.ccs.tencentyun.com",
    "https://registry.docker-cn.com"
  ]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

# 2. 使用構(gòu)建緩存
docker build -t docker-demo:1.0.0 --cache-from docker-demo:latest .

# 解決方案：使用多階段構(gòu)建和輕量級基礎(chǔ)鏡像
# 使用 alpine 版本的鏡像
FROM openjdk:11-jre-slim  # 而不是 openjdk:11
# 或者使用更小的發(fā)行版
FROM openjdk:11-jre-alpine

# 解決方案：檢查日志，確保應(yīng)用在前臺運行

# 錯誤的 CMD：
CMD java -jar app.jar &

# 正確的 CMD：
CMD ["java", "-jar", "app.jar"]
# 或使用 ENTRYPOINT：
ENTRYPOINT ["java", "-jar", "app.jar"]

# 解決方案：更改端口或停止占用進程

# 檢查端口占用
sudo netstat -tlnp | grep :8080

# 停止占用進程
sudo kill <PID>

# 或者使用不同端口
docker run -d -p 8081:8080 docker-demo:1.0.0

# 解決方案：使用自定義網(wǎng)絡(luò)

# 創(chuàng)建網(wǎng)絡(luò)
docker network create my-network

# 將容器連接到同一網(wǎng)絡(luò)
docker run -d --network my-network --name app1 docker-demo:1.0.0
docker run -d --network my-network --name app2 docker-demo:1.0.0

# 在容器內(nèi)部可以通過容器名訪問

# 從 app1 訪問 app2
docker exec app1 curl http://app2:8080/api/health

# 解決方案：使用數(shù)據(jù)卷

# 創(chuàng)建命名卷
docker volume create app-data

# 使用卷
docker run -d \
  -v app-data:/app/data \
  docker-demo:1.0.0

# 或者使用綁定掛載
docker run -d \
  -v /host/path/data:/app/data \
  docker-demo:1.0.0

# 初始化 Swarm 集群
docker swarm init

# 查看節(jié)點
docker node ls

# 創(chuàng)建 overlay 網(wǎng)絡(luò)
docker network create --driver overlay app-network

# 部署服務(wù)棧
docker stack deploy -c docker-compose.yml docker-demo

# 查看服務(wù)
docker service ls

# 查看服務(wù)詳情
docker service ps docker-demo_app

# 擴展服務(wù)
docker service scale docker-demo_app=3

# 更新服務(wù)
docker service update --image docker-demo:2.0.0 docker-demo_app

# 回滾服務(wù)
docker service update --rollback docker-demo_app

# 刪除服務(wù)棧
docker stack rm docker-demo

apiVersion: apps/v1
kind: Deployment
metadata:
  name: docker-demo-deployment
  labels:
    app: docker-demo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: docker-demo
  template:
    metadata:
      labels:
        app: docker-demo
    spec:
      containers:
      - name: docker-demo
        image: yourusername/docker-demo:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        resources:
          limits:
            memory: "512Mi"
            cpu: "500m"
          requests:
            memory: "256Mi"
            cpu: "250m"
        livenessProbe:
          httpGet:
            path: /api/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /api/health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: docker-demo-service
spec:
  selector:
    app: docker-demo
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: LoadBalancer

stages:
  - build
  - test
  - dockerize
  - deploy
variables:
  DOCKER_IMAGE: registry.example.com/yourproject/docker-demo:$CI_COMMIT_REF_SLUG
  MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"
cache:
  paths:
    - .m2/repository/
    - target/
build:
  stage: build
  image: maven:3.8.4-openjdk-11
  script:
    - mvn clean compile
test:
  stage: test
  image: maven:3.8.4-openjdk-11
  script:
    - mvn test
docker-build:
  stage: dockerize
  image: docker:20.10
  services:
    - docker:20.10-dind
  before_script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $DOCKER_IMAGE .
    - docker push $DOCKER_IMAGE
deploy:
  stage: deploy
  image: alpine:latest
  script:
    - apk add --no-cache openssh-client
    - eval $(ssh-agent -s)
    - echo "$SSH_PRIVATE_KEY" | ssh-add -
    - mkdir -p ~/.ssh
    - chmod 700 ~/.ssh
    - ssh-keyscan $DEPLOY_SERVER >> ~/.ssh/known_hosts
    - chmod 644 ~/.ssh/known_hosts
    - |
      ssh $DEPLOY_USER@$DEPLOY_SERVER "
        docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY &&
        docker pull $DOCKER_IMAGE &&
        docker stop docker-demo-app || true &&
        docker rm docker-demo-app || true &&
        docker run -d \
          --name docker-demo-app \
          -p 8080:8080 \
          --restart unless-stopped \
          $DOCKER_IMAGE
      "
  only:
    - master