4.2 План обучения на первые 3 месяца #

# Изучение Git workflow

# День 1: Основы Git
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"
mkdir my-first-repo && cd my-first-repo
git init
echo "# My DevOps Journey" > README.md
git add README.md
git commit -m "Initial commit"

# День 2: Работа с GitHub
# 1. Создать аккаунт на GitHub
# 2. Создать репозиторий my-devops-journey
# 3. Подключить SSH ключи
ssh-keygen -t rsa -b 4096 -C "your.email@example.com"
ssh-add ~/.ssh/id_rsa
# 4. Запушить локальный репозиторий
git remote add origin git@github.com:username/my-devops-journey.git
git push -u origin main

# День 3: Branching и merging
git checkout -b feature/add-learning-log
echo "## Week 1 Learning Log" >> learning-log.md
echo "- Learned basic Linux commands" >> learning-log.md
git add learning-log.md
git commit -m "Add learning log for week 1"
git checkout main
git merge feature/add-learning-log

# День 4: Collaboration workflow
# 1. Fork чужой репозиторий
# 2. Создать feature branch
# 3. Сделать Pull Request
# 4. Участвовать в code review

# День 5: GitHub Actions introduction
mkdir -p .github/workflows
cat > .github/workflows/hello.yml << 'EOF'
name: Hello World
on: [push]
jobs:
  hello:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - run: echo "Hello, DevOps World!"
EOF

# Проектное задание недели:
echo "Создать репозиторий с:"
echo "- README с описанием learning journey"
echo "- Learning log по дням/неделям"
echo "- Простой GitHub Action"
echo "- Минимум 10 commits с понятными сообщениями"

# Python для DevOps - базовые навыки

# День 1: Python основы
#!/usr/bin/env python3
import os
import sys
import subprocess

def get_system_info():
    """Получить основную информацию о системе"""
    info = {
        'hostname': os.uname().nodename,
        'os': os.uname().sysname,
        'python_version': sys.version.split()[0],
        'current_user': os.getenv('USER')
    }
    return info

if __name__ == "__main__":
    info = get_system_info()
    for key, value in info.items():
        print(f"{key}: {value}")

# День 2: Работа с файлами и JSON
import json
import requests

def fetch_github_user(username):
    """Получить информацию о пользователе GitHub"""
    url = f"https://api.github.com/users/{username}"
    response = requests.get(url)
    
    if response.status_code == 200:
        return response.json()
    else:
        return None

# Использование:
user_data = fetch_github_user("octocat")
if user_data:
    print(f"Name: {user_data['name']}")
    print(f"Public repos: {user_data['public_repos']}")

# День 3: Автоматизация с subprocess
import subprocess
import json

def docker_ps():
    """Получить список запущенных контейнеров"""
    try:
        result = subprocess.run(
            ['docker', 'ps', '--format', 'json'],
            capture_output=True,
            text=True,
            check=True
        )
        
        containers = []
        for line in result.stdout.strip().split('\n'):
            if line:
                containers.append(json.loads(line))
        
        return containers
    except subprocess.CalledProcessError as e:
        print(f"Error: {e}")
        return []

# День 4: Мониторинг скрипт
import psutil
import time

def monitor_system(duration=60):
    """Мониторинг системы в течение указанного времени"""
    print("Starting system monitoring...")
    
    start_time = time.time()
    while time.time() - start_time < duration:
        cpu_percent = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        
        print(f"CPU: {cpu_percent}% | "
              f"Memory: {memory.percent}% | "
              f"Disk: {disk.percent}%")
        
        time.sleep(5)

# День 5: CLI инструмент с argparse
import argparse

def main():
    parser = argparse.ArgumentParser(description='DevOps utility tool')
    parser.add_argument('--check-disk', action='store_true', help='Check disk usage')
    parser.add_argument('--check-memory', action='store_true', help='Check memory usage')
    parser.add_argument('--docker-ps', action='store_true', help='List Docker containers')
    
    args = parser.parse_args()
    
    if args.check_disk:
        disk = psutil.disk_usage('/')
        print(f"Disk usage: {disk.percent}%")
    
    if args.check_memory:
        memory = psutil.virtual_memory()
        print(f"Memory usage: {memory.percent}%")
    
    if args.docker_ps:
        containers = docker_ps()
        print(f"Running containers: {len(containers)}")

if __name__ == "__main__":
    main()

# Практическое изучение Docker

# День 1: Docker basics
# Установка Docker (если не сделано ранее)
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# Базовые команды
docker --version
docker run hello-world
docker images
docker ps -a

# День 2: Работа с контейнерами
# Интерактивная работа
docker run -it ubuntu:20.04 bash
# Внутри контейнера:
apt update && apt install -y curl
curl -I https://google.com
exit

# Запуск веб-сервера
docker run -d -p 8080:80 --name my-nginx nginx:latest
curl http://localhost:8080
docker logs my-nginx
docker stop my-nginx && docker rm my-nginx

# День 3: Создание собственных образов
mkdir docker-lab && cd docker-lab

# Простое Python приложение
cat > app.py << 'EOF'
from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return f"Hello from container! Hostname: {os.uname().nodename}"

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

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

cat > requirements.txt << 'EOF'
Flask==2.0.1
EOF

# Dockerfile
cat > Dockerfile << 'EOF'
FROM python:3.9-alpine

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY app.py .

EXPOSE 5000

CMD ["python", "app.py"]
EOF

# Сборка и запуск
docker build -t my-python-app .
docker run -d -p 5000:5000 --name python-app my-python-app
curl http://localhost:5000

# День 4: Docker Compose
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=development
    depends_on:
      - redis

  redis:
    image: redis:6-alpine
    ports:
      - "6379:6379"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - web
EOF

# Запуск multi-container приложения
docker-compose up -d
docker-compose ps
docker-compose logs web
docker-compose down

# День 5: Best practices и оптимизация
# Multi-stage build пример
cat > Dockerfile.optimized << 'EOF'
# Build stage
FROM python:3.9 as builder
WORKDIR /app
COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt

# Production stage
FROM python:3.9-alpine
RUN addgroup -g 1001 -S python && \
    adduser -S python -u 1001
COPY --from=builder /app/wheels /wheels
COPY --from=builder /app/requirements.txt .
RUN pip install --no-cache /wheels/*
USER python
WORKDIR /app
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]
EOF

# Проектное задание месяца 1:
echo "Создать проект 'System Monitor Dashboard':"
echo "- Python скрипт для сбора метрик системы"
echo "- Веб-интерфейс на Flask для отображения метрик"
echo "- Dockerfile для контейнеризации"
echo "- Docker Compose для запуска с Redis/database"
echo "- GitHub репозиторий с документацией"

# Изучение непрерывной интеграции и доставки

# Неделя 5: Основы CI/CD
# .github/workflows/ci.yml
name: Continuous Integration

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: 3.9
        
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
        pip install pytest pytest-cov flake8
        
    - name: Lint with flake8
      run: |
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
        
    - name: Test with pytest
      run: |
        pytest --cov=./ --cov-report=xml
        
    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v1

  build:
    needs: test
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Build Docker image
      run: |
        docker build -t my-app:${{ github.sha }} .
        docker tag my-app:${{ github.sha }} my-app:latest
        
    - name: Run container tests
      run: |
        docker run --rm my-app:latest python -c "import app; print('App imports successfully')"

# Неделя 6: Деплой и окружения
# .github/workflows/deploy.yml  
name: Deploy to Staging

on:
  push:
    branches: [ develop ]

jobs:
  deploy-staging:
    runs-on: ubuntu-latest
    environment: staging
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Configure AWS credentials
      uses: aws-actions/configure-aws-credentials@v1
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: us-east-1
        
    - name: Login to Amazon ECR
      id: login-ecr
      uses: aws-actions/amazon-ecr-login@v1
      
    - name: Build and push Docker image
      env:
        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
        ECR_REPOSITORY: my-app
        IMAGE_TAG: ${{ github.sha }}
      run: |
        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
        docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
        
    - name: Deploy to ECS
      run: |
        aws ecs update-service --cluster staging --service my-app --force-new-deployment

# Практические задания недель 5-6:
# 1. Настроить CI pipeline с тестами и линтингом
# 2. Добавить сборку Docker образов
# 3. Настроить деплой в staging окружение
# 4. Добавить уведомления в Slack при успешном/неудачном деплое
# 5. Создать production pipeline с manual approval

# Неделя 7: AWS основы

# День 1: Настройка AWS CLI и основы
aws configure
aws sts get-caller-identity

# Создание EC2 инстанса
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1d0 \
  --instance-type t2.micro \
  --key-name my-key \
  --security-group-ids sg-12345678 \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=DevOps-Learning}]'

# День 2: S3 и статические сайты
aws s3 mb s3://my-devops-portfolio-$(date +%s)
aws s3 website s3://my-devops-portfolio-$(date +%s) \
  --index-document index.html \
  --error-document error.html

# Загрузка простого сайта
echo "<h1>My DevOps Portfolio</h1>" > index.html
aws s3 cp index.html s3://my-devops-portfolio-$(date +%s)/

# День 3: RDS и базы данных
aws rds create-db-instance \
  --db-instance-identifier devops-db \
  --db-instance-class db.t3.micro \
  --engine mysql \
  --master-username admin \
  --master-user-password MyPassword123 \
  --allocated-storage 20

# День 4: Load Balancer и Auto Scaling
# Создание Application Load Balancer
aws elbv2 create-load-balancer \
  --name devops-alb \
  --subnets subnet-12345 subnet-67890 \
  --security-groups sg-12345678

# День 5: CloudWatch мониторинг
aws cloudwatch put-metric-alarm \
  --alarm-name cpu-mon \
  --alarm-description "Alarm when CPU exceeds 70%" \
  --metric-name CPUUtilization \
  --namespace AWS/EC2 \
  --statistic Average \
  --period 300 \
  --threshold 70 \
  --comparison-operator GreaterThanThreshold

# Неделя 8: Infrastructure as Code с Terraform
mkdir terraform-lab && cd terraform-lab

# main.tf - базовая инфраструктура
cat > main.tf << 'EOF'
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

# VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "devops-vpc"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "devops-igw"
  }
}

# Public Subnet
resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "us-east-1a"
  map_public_ip_on_launch = true

  tags = {
    Name = "devops-public-subnet"
  }
}

# Route Table
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }

  tags = {
    Name = "devops-public-rt"
  }
}

resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

# Security Group
resource "aws_security_group" "web" {
  name_prefix = "devops-web-"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]  # В продакшене ограничить!
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# EC2 Instance
resource "aws_instance" "web" {
  ami                    = "ami-0c55b159cbfafe1d0"
  instance_type          = "t2.micro"
  key_name               = "my-key"  # Создать заранее
  vpc_security_group_ids = [aws_security_group.web.id]
  subnet_id              = aws_subnet.public.id

  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<h1>Hello from Terraform!</h1>" > /var/www/html/index.html
              EOF

  tags = {
    Name = "devops-web-server"
  }
}

# Outputs
output "instance_ip" {
  value = aws_instance.web.public_ip
}

output "instance_dns" {
  value = aws_instance.web.public_dns
}
EOF

# Применение конфигурации
terraform init
terraform plan
terraform apply

# Проверка результата
curl http://$(terraform output -raw instance_ip)

# Очистка ресурсов
terraform destroy

# Неделя 9: Основы Kubernetes

# Установка и настройка
# Использовать minikube или kind для локального изучения
minikube start --driver=docker

# День 1: Pods и основные объекты
kubectl run nginx --image=nginx:latest --port=80
kubectl get pods
kubectl describe pod nginx
kubectl logs nginx
kubectl delete pod nginx

# Pod из YAML файла
cat > pod.yaml << 'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  containers:
  - name: app
    image: nginx:alpine
    ports:
    - containerPort: 80
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"
EOF

kubectl apply -f pod.yaml

# День 2: Services и networking
cat > service.yaml << 'EOF'
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort
EOF

kubectl apply -f service.yaml
kubectl get services
minikube service my-app-service --url

# День 3: Deployments
cat > deployment.yaml << 'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: nginx:alpine
        ports:
        - containerPort: 80
EOF

kubectl apply -f deployment.yaml
kubectl get deployments
kubectl get pods

# Масштабирование
kubectl scale deployment my-app-deployment --replicas=5

# Rolling update
kubectl set image deployment/my-app-deployment app=nginx:latest
kubectl rollout status deployment/my-app-deployment

# День 4: ConfigMaps и Secrets
cat > configmap.yaml << 'EOF'
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "mysql://localhost:3306/mydb"
  log_level: "info"
  config.properties: |
    server.port=8080
    server.host=0.0.0.0
EOF

kubectl apply -f configmap.yaml

# Secret
kubectl create secret generic app-secret \
  --from-literal=db-password='supersecret123' \
  --from-literal=api-key='abc123xyz'

# День 5: Volumes и persistence
cat > persistent-pod.yaml << 'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: persistent-app
spec:
  containers:
  - name: app
    image: nginx:alpine
    volumeMounts:
    - name: html-volume
      mountPath: /usr/share/nginx/html
  volumes:
  - name: html-volume
    emptyDir: {}
EOF

# Неделя 10: Продвинутые концепции Kubernetes
# Ingress, Helm, мониторинг в K8s

# Финальный проект: Full-Stack DevOps Pipeline

## Цель проекта:
Создать complete end-to-end DevOps pipeline для веб-приложения

## Компоненты проекта:

### 1. Приложение (Неделя 11)
- **Frontend:** Simple React/Vue.js app или статический сайт
- **Backend:** REST API на Python/Node.js с базой данных
- **Database:** PostgreSQL или MySQL
- **Мониторинг:** Health checks, metrics endpoints

### 2. Инфраструктура (Неделя 11)
- **Containerization:** Docker и Docker Compose для локальной разработки
- **Cloud Infrastructure:** Terraform для provision AWS/Azure ресурсов
- **Kubernetes:** Деплой приложения в K8s кластер
- **Networking:** Load balancer, ingress, SSL certificates

### 3. CI/CD Pipeline (Неделя 12)
- **Source Control:** Git workflow с feature branches
- **Continuous Integration:** 
  - Automated tests (unit, integration)
  - Code quality checks (linting, security scanning)
  - Docker image building
- **Continuous Deployment:**
  - Staging environment автодеплой
  - Production деплой с manual approval
  - Rollback capabilities

### 4. Monitoring & Observability (Неделя 12)
- **Metrics:** Prometheus + Grafana
- **Logs:** Centralized logging (ELK или cloud-native)
- **Alerting:** Critical alerts setup
- **Health Checks:** Application и infrastructure monitoring

## Deliverables:
1. **GitHub Repository** с полным исходным кодом
2. **Documentation** в README с архитектурой и setup инструкциями
3. **Live Demo** - работающее приложение в облаке
4. **Presentation** - 10-минутная презентация проекта
5. **Blog Post** - техническая статья о том, что изучили

## Критерии успеха:
- [ ] Приложение доступно по HTTPS в интернете
- [ ] Автоматический деплой при push в main branch
- [ ] Мониторинг показывает key metrics
- [ ] Infrastructure полностью описана в коде
- [ ] Есть план disaster recovery
- [ ] Документация позволяет воспроизвести setup

# Week X Review - Month Y

## Technical Progress ⚙️
### Completed:
- [ ] All planned tutorials/courses
- [ ] Hands-on labs and exercises  
- [ ] Weekly project milestone

### Struggled with:
- Specific technical challenges
- Concepts that were difficult
- Time management issues

### Key learnings:
- Most important insights
- "Aha!" moments
- Connections between concepts

## Practical Outcomes 🛠️
- [ ] Code commits this week: ___
- [ ] New GitHub repositories: ___
- [ ] Blog posts/documentation: ___
- [ ] Community interactions: ___

## Skill Level Updates 📈
Rate your current level (1-10):
- Linux: ___/10 (previous: ___/10)
- Git: ___/10 (previous: ___/10)  
- Docker: ___/10 (previous: ___/10)
- Python/Bash: ___/10 (previous: ___/10)
- Cloud (AWS/Azure/GCP): ___/10 (previous: ___/10)

## Next Week Goals 🎯
1. Primary focus area: _______________
2. Specific learning objectives:
   - [ ] ________________________
   - [ ] ________________________  
   - [ ] ________________________
3. Practical deliverable: ___________

## Networking & Community 👥
- [ ] Participated in forums/Discord
- [ ] Connected with new DevOps professionals
- [ ] Shared knowledge or helped others
- [ ] Attended meetups/webinars

## Time Investment ⏰
- Structured learning: ___ hours
- Hands-on practice: ___ hours  
- Community engagement: ___ hours
- Project work: ___ hours
- **Total: ___ hours** (Target: 15-25 hours/week)

## Reflection Questions 🤔
1. What energized me most this week?
2. What frustrated me most?
3. What would I do differently?
4. How confident do I feel about DevOps concepts?
5. What support do I need for next week?

# Автоматизированная система трекинга прогресса

class LearningTracker:
    def __init__(self):
        self.skills = {
            'linux': {'current': 0, 'target': 7, 'evidence': []},
            'git': {'current': 0, 'target': 8, 'evidence': []},
            'docker': {'current': 0, 'target': 7, 'evidence': []},
            'kubernetes': {'current': 0, 'target': 6, 'evidence': []},
            'cloud': {'current': 0, 'target': 6, 'evidence': []},
            'ci_cd': {'current': 0, 'target': 7, 'evidence': []},
            'iac': {'current': 0, 'target': 6, 'evidence': []},
            'monitoring': {'current': 0, 'target': 5, 'evidence': []}
        }
        
    def update_skill(self, skill, level, evidence):
        """Обновить уровень навыка с доказательствами"""
        if skill in self.skills:
            self.skills[skill]['current'] = level
            self.skills[skill]['evidence'].append({
                'date': datetime.now(),
                'evidence': evidence,
                'level': level
            })
    
    def calculate_readiness(self):
        """Рассчитать готовность к job applications"""
        total_current = sum(skill['current'] for skill in self.skills.values())
        total_target = sum(skill['target'] for skill in self.skills.values())
        
        readiness = (total_current / total_target) * 100
        
        if readiness >= 70:
            return "Ready for junior positions"
        elif readiness >= 50:
            return "Continue building skills"
        else:
            return "Focus on fundamentals"
    
    def generate_focus_areas(self):
        """Определить области для приоритетного изучения"""
        gaps = []
        for skill, data in self.skills.items():
            gap = data['target'] - data['current']
            if gap > 2:
                gaps.append((skill, gap))
        
        return sorted(gaps, key=lambda x: x[1], reverse=True)

# Пример использования:
tracker = LearningTracker()
tracker.update_skill('docker', 6, 'Built multi-container app with docker-compose')
tracker.update_skill('linux', 7, 'Created system monitoring scripts')

print(tracker.calculate_readiness())
print("Focus on:", tracker.generate_focus_areas()[:3])