Questions d'entretien pour un Ingénieur DevOps Junior : Guide Complet

# Opérations sur les fichiers
ls -la                    # Lister les fichiers avec les détails
cd /var/log              # Changer de répertoire
cat /etc/hosts           # Afficher le contenu du fichier
tail -f /var/log/app.log # Suivre le fichier de log en temps réel
grep "error" app.log     # Rechercher des motifs

# Gestion des processus
ps aux | grep nginx      # Lister les processus
top                      # Surveiller les ressources système
kill -9 1234            # Forcer l'arrêt du processus
systemctl status nginx   # Vérifier l'état du service
systemctl restart nginx  # Redémarrer le service

# Permissions de fichier
chmod 755 script.sh      # Modifier les permissions du fichier
chown user:group file    # Modifier le propriétaire
ls -l                    # Afficher les permissions

# Utilisation du disque
df -h                    # Utilisation de l'espace disque
du -sh /var/log          # Taille du répertoire
free -h                  # Utilisation de la mémoire

# Réseau
netstat -tulpn           # Afficher les ports d'écoute
curl https://api.com     # Faire une requête HTTP
ping google.com          # Tester la connectivité
ssh user@server          # Connexion à distance

# 1. Vérifier l'état du service
systemctl status nginx
# Rechercher les messages d'erreur

# 2. Vérifier les logs
journalctl -u nginx -n 50
# ou
tail -f /var/log/nginx/error.log

# 3. Vérifier la syntaxe de la configuration
nginx -t

# 4. Vérifier si le port est déjà utilisé
netstat -tulpn | grep :80
# ou
lsof -i :80

# 5. Vérifier les permissions de fichier
ls -l /etc/nginx/nginx.conf
ls -ld /var/log/nginx

# 6. Vérifier l'espace disque
df -h

# 7. Essayer de démarrer manuellement pour plus de détails
nginx -g 'daemon off;'

# 8. Vérifier SELinux/AppArmor (si activé)
getenforce
ausearch -m avc -ts recent

# Initialiser le dépôt
git init
git clone https://github.com/user/repo.git

# Vérifier l'état
git status
git log --oneline

# Flux de travail de base
git add .                    # Ajouter les modifications à la zone de préparation
git commit -m "Add feature"  # Valider les modifications
git push origin main         # Pousser vers le dépôt distant

# Création de branches
git branch feature-x         # Créer une branche
git checkout feature-x       # Basculer vers la branche
git checkout -b feature-y    # Créer et basculer

# Fusion
git checkout main
git merge feature-x

# Récupérer les dernières modifications
git pull origin main

# Annuler les modifications
git reset --hard HEAD        # Rejeter les modifications locales
git revert abc123           # Annuler un commit spécifique

# Masquer les modifications
git stash                    # Sauvegarder temporairement les modifications
git stash pop               # Restaurer les modifications masquées

# Afficher les différences
git diff                     # Modifications non préparées
git diff --staged           # Modifications préparées

# 1. Tenter la fusion
git merge feature-branch
# Auto-merging file.txt
# CONFLICT (content): Merge conflict in file.txt

# 2. Vérifier les fichiers en conflit
git status
# Unmerged paths:
#   both modified:   file.txt

# 3. Ouvrir le fichier en conflit
cat file.txt
# <<<<<<< HEAD
# Contenu de la branche actuelle
# =======
# Contenu de la branche entrante
# >>>>>>> feature-branch

# 4. Modifier le fichier pour résoudre le conflit
# Supprimer les marqueurs de conflit et conserver les modifications souhaitées

# 5. Préparer le fichier résolu
git add file.txt

# 6. Terminer la fusion
git commit -m "Resolve merge conflict"

# Alternative : Abandonner la fusion
git merge --abort

# .github/workflows/ci-cd.yml
name: Pipeline CI/CD

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

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    
    steps:
    - name: Extraire le code
      uses: actions/checkout@v3
    
    - name: Configurer Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
    
    - name: Installer les dépendances
      run: npm ci
    
    - name: Exécuter les tests
      run: npm test
    
    - name: Construire l'application
      run: npm run build
    
    - name: Exécuter linter
      run: npm run lint

  deploy:
    needs: build-and-test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    steps:
    - name: Déployer en production
      run: |
        echo "Déploiement en production..."
        # Ajouter les commandes de déploiement ici

# Exemple de Dockerfile
FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

# Images
docker pull nginx:latest          # Télécharger l'image
docker images                     # Lister les images
docker rmi nginx:latest          # Supprimer l'image
docker build -t myapp:1.0 .      # Construire l'image

# Conteneurs
docker run -d -p 80:80 nginx     # Exécuter le conteneur
docker ps                         # Lister les conteneurs en cours d'exécution
docker ps -a                      # Lister tous les conteneurs
docker stop container_id          # Arrêter le conteneur
docker start container_id         # Démarrer le conteneur
docker restart container_id       # Redémarrer le conteneur
docker rm container_id            # Supprimer le conteneur

# Logs et débogage
docker logs container_id          # Afficher les logs
docker logs -f container_id       # Suivre les logs
docker exec -it container_id bash # Entrer dans le conteneur
docker inspect container_id       # Informations détaillées

# Nettoyage
docker system prune              # Supprimer les données inutilisées
docker volume prune              # Supprimer les volumes inutilisés

# Docker Compose
docker-compose up -d             # Démarrer les services
docker-compose down              # Arrêter les services
docker-compose logs -f           # Afficher les logs

version: '3.8'

services:
  web:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=db
      - DB_PORT=5432
      - DB_NAME=myapp
    depends_on:
      - db
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=secret
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    restart: unless-stopped

volumes:
  postgres_data:

aws ec2 run-instances \
  --image-id ami-0abcdef1234567890 \
  --instance-type t2.micro \
  --key-name my-key-pair \
  --security-group-ids sg-0123456789abcdef0 \
  --subnet-id subnet-0123456789abcdef0 \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=WebServer}]'

# main.tf
provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "WebServer"
    Environment = "Production"
  }
}

resource "aws_security_group" "web_sg" {
  name        = "web-sg"
  description = "Autoriser le trafic HTTP"

  ingress {
    from_port   = 80
    to_port     = 80
    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"]
  }
}

# 1. Initialiser Terraform
terraform init
# Télécharge les fournisseurs et les modules

# 2. Formater le code
terraform fmt
# Formate les fichiers .tf

# 3. Valider la configuration
terraform validate
# Vérifie la syntaxe

# 4. Planifier les modifications
terraform plan
# Montre ce qui sera créé/modifié/détruit

# 5. Appliquer les modifications
terraform apply
# Crée/met à jour l'infrastructure
# Demande une confirmation

# 6. Afficher l'état
terraform show
# Affiche l'état actuel

# 7. Détruire l'infrastructure
terraform destroy
# Supprime toutes les ressources

# variables.tf
variable "instance_type" {
  description = "Type d'instance EC2"
  type        = string
  default     = "t2.micro"
}

variable "environment" {
  description = "Nom de l'environnement"
  type        = string
}

# terraform.tfvars
environment = "production"
instance_type = "t2.small"

# Temps de réponse moyen
rate(http_request_duration_seconds_sum[5m])
/ rate(http_request_duration_seconds_count[5m])

# Taux d'erreur
sum(rate(http_requests_total{status=~"5.."}[5m]))
/ sum(rate(http_requests_total[5m]))

# Utilisation du CPU
100 - (avg by (instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# filebeat.yml
filebeat.inputs:
- type: log
  enabled: true
  paths:
    - /var/log/app/*.log
  fields:
    app: myapp
    environment: production

output.elasticsearch:
  hosts: ["elasticsearch:9200"]
  index: "app-logs-%{+yyyy.MM.dd}"

processors:
  - add_host_metadata: ~
  - add_cloud_metadata: ~

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

# Obtenir les ressources
kubectl get pods
kubectl get deployments
kubectl get services

# Décrire la ressource
kubectl describe pod nginx-pod

# Créer à partir d'un fichier
kubectl apply -f deployment.yaml

# Supprimer la ressource
kubectl delete pod nginx-pod

# Afficher les logs
kubectl logs nginx-pod

# Exécuter une commande dans le pod
kubectl exec -it nginx-pod -- /bin/bash

# Redirection de port
kubectl port-forward pod/nginx-pod 8080:80

# inventory.ini
[webservers]
web1.example.com
web2.example.com

[databases]
db1.example.com

[all: vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/id_rsa

# playbook.yml
---
- name: Configurer les serveurs web
  hosts: webservers
  become: yes
  
  vars:
    app_port: 8080
    app_user: webapp
  
  tasks:
    - name: Mettre à jour le cache apt
      apt:
        update_cache: yes
        cache_valid_time: 3600
    
    - name: Installer les paquets requis
      apt:
        name:
          - nginx
          - python3
          - git
        state: present
    
    - name: Créer un utilisateur pour l'application
      user:
        name: "{{ app_user }}"
        shell: /bin/bash
        create_home: yes
    
    - name: Copier la configuration nginx
      template:
        src: templates/nginx.conf.j2
        dest: /etc/nginx/sites-available/default
      notify: Redémarrer nginx
    
    - name: S'assurer que nginx est en cours d'exécution
      service:
        name: nginx
        state: started
        enabled: yes
    
    - name: Déployer l'application
      git:
        repo: https://github.com/example/app.git
        dest: /var/www/app
        version: main
      become_user: "{{ app_user }}"
  
  handlers:
    - name: Redémarrer nginx
      service:
        name: nginx
        state: restarted

# templates/nginx.conf.j2
server {
    listen {{ app_port }};
    server_name {{ ansible_hostname }};
    
    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

# Vérifier la syntaxe
ansible-playbook playbook.yml --syntax-check

# Exécution à sec (mode vérification)
ansible-playbook playbook.yml --check

# Exécuter le playbook
ansible-playbook -i inventory.ini playbook.yml

# Exécuter avec des tags spécifiques
ansible-playbook playbook.yml --tags "deploy"

# Limiter à des hôtes spécifiques
ansible-playbook playbook.yml --limit webservers

---
- name: Configurer l'infrastructure
  hosts: all
  become: yes
  
  roles:
    - common
    - webserver
    - monitoring

# Ping tous les hôtes
ansible all -i inventory.ini -m ping

# Exécuter une commande sur tous les hôtes
ansible all -i inventory.ini -a "uptime"

# Installer un paquet
ansible webservers -i inventory.ini -m apt -a "name=nginx state=present" --become

# Copier un fichier
ansible all -i inventory.ini -m copy -a "src=/local/file dest=/remote/file"

# Redémarrer un service
ansible webservers -i inventory.ini -m service -a "name=nginx state=restarted" --become

#!/bin/bash

# Script de sauvegarde de base de données avec rotation
set -e  # Sortir en cas d'erreur
set -u  # Sortir en cas de variable non définie

# Configuration
DB_NAME="myapp"
DB_USER="backup_user"
BACKUP_DIR="/var/backups/mysql"
RETENTION_DAYS=7
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="${BACKUP_DIR}/${DB_NAME}_${DATE}.sql.gz"
LOG_FILE="/var/log/mysql_backup.log"

# Fonction pour enregistrer les messages
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# Fonction pour envoyer une notification
send_notification() {
    local status=$1
    local message=$2
    
    # Envoyer à Slack
    curl -X POST -H 'Content-type: application/json' \
        --data "{\"text\":\"Backup ${status}: ${message}\"}" \
        "$SLACK_WEBHOOK_URL"
}

# Créer le répertoire de sauvegarde s'il n'existe pas
mkdir -p "$BACKUP_DIR"

# Démarrer la sauvegarde
log "Démarrage de la sauvegarde de la base de données : $DB_NAME"

# Effectuer la sauvegarde
if mysqldump -u "$DB_USER" -p"$DB_PASSWORD" "$DB_NAME" | gzip > "$BACKUP_FILE"; then
    log "Sauvegarde terminée avec succès : $BACKUP_FILE"
    
    # Obtenir la taille du fichier
    SIZE=$(du -h "$BACKUP_FILE" | cut -f1)
    log "Taille de la sauvegarde : $SIZE"
    
    # Supprimer les anciennes sauvegardes
    log "Suppression des sauvegardes plus anciennes que $RETENTION_DAYS jours"
    find "$BACKUP_DIR" -name "${DB_NAME}_*.sql.gz" -mtime +$RETENTION_DAYS -delete
    
    # Télécharger vers S3 (facultatif)
    if command -v aws &> /dev/null; then
        log "Téléchargement de la sauvegarde vers S3"
        aws s3 cp "$BACKUP_FILE" "s3://my-backups/mysql/" --storage-class GLACIER
    fi
    
    send_notification "SUCCESS" "Base de données $DB_NAME sauvegardée avec succès ($SIZE)"
else
    log "ERREUR : La sauvegarde a échoué"
    send_notification "FAILED" "La sauvegarde de la base de données $DB_NAME a échoué"
    exit 1
fi

log "Processus de sauvegarde terminé"

#!/bin/bash

# Script de vérification de l'état du service
SERVICES=("nginx" "mysql" "redis")
ENDPOINTS=("http://localhost:80" "http://localhost:8080/health