# Образы
docker images
docker pull nginx:1.21
docker build -t myapp:1.0 .
docker rmi nginx:1.21
docker prune

# Контейнеры
docker ps -a
docker run -d nginx:1.21
docker run -it ubuntu bash
docker start <container>
docker stop <container>
docker rm <container>
docker logs -f <container>
docker exec -it <container> sh

# Volumes
docker volume ls
docker volume create mydata

# Сети
docker network ls
docker network create mynet

FROM python:3.11-slim

LABEL maintainer="dev@example.com"
WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

# Stage 1: Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules

USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

__pycache__
*.pyc
.git
.env
node_modules
Dockerfile
docker-compose.yml

version: '3.8'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    environment:
      - DEBUG=1
      - DATABASE_URL=postgres://user:pass@db:5432/myapp
    depends_on:
      - db
      - redis
    volumes:
      - ./app:/app
    restart: unless-stopped

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

  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    depends_on:
      - web

volumes:
  postgres_data:

networks:
  default:
    driver: bridge

docker-compose up -d
docker-compose up -d --build
docker-compose logs -f
docker-compose logs -f web
docker-compose down
docker-compose down -v
docker-compose up -d --scale web=3
docker-compose restart

# .env файл
COMPOSE_PROJECT_NAME=myapp
DATABASE_URL=postgres://user:pass@db:5432/myapp

# docker-compose.yml
services:
  web:
    env_file:
      - .env
    environment:
      - DATABASE_URL=${DATABASE_URL}

services:
  web:
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started

version: '3.8'

services:
  api-gateway:
    build: ./api-gateway
    ports:
      - "8080:8080"
    depends_on:
      - user-service
      - order-service

  user-service:
    build: ./services/user
    depends_on:
      postgres:
        condition: service_healthy

  order-service:
    build: ./services/order
    environment:
      - KAFKA_BROKERS=kafka:9092
    depends_on:
      - postgres
      - kafka

  postgres:
    image: postgres:15-alpine
    healthcheck:
      test: ["CMD-SHELL", "pg_isready"]
      interval: 10s

  kafka:
    image: confluentinc/cp-kafka:7.4.0
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
    depends_on:
      - zookeeper

  zookeeper:
    image: confluentinc/cp-zookeeper:7.4.0

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

upstream user_service {
    server user-service:8001;
}

upstream order_service {
    server order-service:8002;
}

server {
    listen 80;

    location /api/users {
        proxy_pass http://user_service;
    }

    location /api/orders {
        proxy_pass http://order_service;
    }
}

docker network create my-bridge
docker network create --driver overlay my-overlay

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: true

volumes:
  db_data:
  
services:
  db:
    volumes:
      - db_data:/var/lib/postgresql/data
      - /host/path:/container/path

docker run --rm -v volume_name:/data -v $(pwd):/backup alpine tar czf /backup/backup.tar.gz -C /data .
docker run --rm -v volume_name:/data -v $(pwd):/backup alpine tar xzf /backup/backup.tar.gz -C /data

RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

# Сканирование уязвимостей
trivy image myapp:latest

services:
  web:
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

project/
├── docker-compose.yml
├── Dockerfile
├── .dockerignore
├── nginx.conf
├── .env
└── services/
    ├── api/
    │   ├── Dockerfile
    └── worker/
        ├── Dockerfile

docker ps -a
docker stats
docker-compose logs --tail=100
docker-compose exec web sh
docker-compose build --no-cache

build:
  stage: build
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

deploy:
  stage: deploy
  script:
    - docker-compose up -d
  only:
    - main

docker swarm init
docker stack deploy -c docker-compose.yml myapp
docker service ls
docker service scale myapp_web=5
docker service update --image myapp:2.0 myapp_web