// app.js
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Docker!', timestamp: new Date() });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

{
  "name": "docker-demo",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  }
}

# 使用官方 Node.js 镜像作为基础镜像
FROM node:20-alpine

# 设置工作目录
WORKDIR /app

# 复制 package.json 和 package-lock.json（如果有）
COPY package*.json ./

# 安装依赖
RUN npm ci --only=production

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["npm", "start"]

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

# 查看镜像
docker images

# 运行容器
docker run -d -p 3000:3000 --name my-app my-node-app:1.0

# 查看运行日志
docker logs my-app

# 访问服务
curl http://localhost:3000

# 停止并删除容器
docker stop my-app
docker rm my-app

version: '3.8'

services:
  # 应用服务
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:password@db:5432/mydb
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    restart: unless-stopped
    networks:
      - app-network

  # PostgreSQL 数据库
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=mydb
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network
    restart: unless-stopped

  # Redis 缓存
  redis:
    image: redis:7-alpine
    networks:
      - app-network
    restart: unless-stopped

volumes:
  postgres-data:

networks:
  app-network:
    driver: bridge

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

# 查看服务状态
docker compose ps

# 查看日志
docker compose logs -f app

# 停止所有服务
docker compose down

# 停止并删除数据卷（慎用！）
docker compose down -v

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
  labels:
    app: my-app
spec:
  replicas: 3  # 运行 3 个副本
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-node-app:1.0
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: database-url
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer  # 云厂商会自动创建负载均衡器

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
stringData:
  database-url: "postgresql://user:password@db:5432/mydb"

# 创建命名空间（可选）
kubectl create namespace production

# 创建 Secret
kubectl apply -f k8s/secrets.yaml -n production

# 部署应用
kubectl apply -f k8s/deployment.yaml -n production

# 创建服务
kubectl apply -f k8s/service.yaml -n production

# 查看部署状态
kubectl get deployments -n production
kubectl get pods -n production
kubectl get services -n production

# 查看 Pod 日志
kubectl logs -f deployment/my-app-deployment -n production

# 扩容到 5 个副本
kubectl scale deployment my-app-deployment --replicas=5 -n production

# 滚动更新镜像
kubectl set image deployment/my-app-deployment my-app=my-node-app:2.0 -n production

# 查看更新状态
kubectl rollout status deployment/my-app-deployment -n production

# 回滚到上一个版本
kubectl rollout undo deployment/my-app-deployment -n production

# 构建阶段
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 生产阶段
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
ENV NODE_ENV=production
EXPOSE 3000
CMD ["node", "dist/index.js"]

// 存活探针（livenessProbe）- 应用是否活着
app.get('/health', (req, res) => {
  res.json({ status: 'ok', timestamp: new Date() });
});

// 就绪探针（readinessProbe）- 应用是否可以接收流量
app.get('/ready', (req, res) => {
  if (dbConnected && cacheConnected) {
    res.json({ status: 'ready' });
  } else {
    res.status(503).json({ status: 'not ready' });
  }
});

// 使用结构化日志
const log = (level, message, meta = {}) => {
  console.log(JSON.stringify({
    level,
    message,
    timestamp: new Date().toISOString(),
    ...meta
  }));
};

log('info', 'Server started', { port: PORT });

# Prometheus 抓取配置
annotations:
  prometheus.io/scrape: "true"
  prometheus.io/port: "3000"
  prometheus.io/path: "/metrics"

name: Deploy to Kubernetes

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - name: Build and push Docker image
      uses: docker/build-push-action@v5
      with:
        push: true
        tags: registry.example.com/my-app:${{ github.sha }}
    
    - name: Deploy to Kubernetes
      uses: azure/k8s-deploy@v4
      with:
        manifests: |
          k8s/deployment.yaml
          k8s/service.yaml
        images: |
          registry.example.com/my-app:${{ github.sha }}
        namespace: production

# 测试 DNS
docker run --rm alpine nslookup google.com

# 检查网络策略
kubectl get networkpolicy

# K8s 持久化存储示例
volumes:
- name: data-volume
  persistentVolumeClaim:
    claimName: my-pvc

resources:
  requests:
    memory: "128Mi"  # 保证至少这么多
    cpu: "100m"      # 100 毫核
  limits:
    memory: "256Mi"  # 最多用这么多
    cpu: "500m"      # 500 毫核