Bonnes pratiques

Ce document présente les bonnes pratiques recommandées pour l'utilisation de la plateforme Atlas. Suivre ces recommandations vous aidera à tirer le meilleur parti de la plateforme et à éviter les problèmes courants.

Applications Cloud Ready

La plateforme Atlas est conçue pour héberger des applications cloud ready, c'est-à-dire des applications spécifiquement conçues pour tirer parti des avantages du cloud computing. Pour développer des applications cloud ready efficaces, nous recommandons fortement de suivre la méthodologie Twelve-Factor App.

Les 12 facteurs

  1. Base de code unique : Une seule base de code suivie avec un système de contrôle de version, déployable dans de multiples environnements
  2. Dépendances explicites : Déclarez et isolez explicitement les dépendances
  3. Configuration dans l'environnement : Stockez la configuration dans des variables d'environnement
  4. Services externes : Traitez les services externes comme des ressources attachées
  5. Build, release, run : Séparez strictement les étapes de build et d'exécution
  6. Processus sans état : Exécutez l'application comme un ou plusieurs processus sans état
  7. Associations de ports : Exportez les services via des associations de ports
  8. Concurrence : Mettez à l'échelle via le modèle de processus
  9. Jetable : Maximisez la robustesse avec des démarrages rapides et des arrêts gracieux
  10. Parité dev/prod : Gardez les environnements de développement, de préproduction et de production aussi similaires que possible
  11. Logs : Traitez les logs comme des flux d'événements
  12. Processus d'administration : Exécutez les tâches d'administration/gestion comme des processus ponctuels

Avantages des applications 12-factor sur Atlas

L'adoption de la méthodologie 12-factor pour vos applications sur Atlas présente plusieurs avantages :

  • Portabilité : Vos applications peuvent être facilement déployées dans différents environnements
  • Scalabilité : Vos applications peuvent être mises à l'échelle horizontalement sans modification
  • Résilience : Vos applications sont plus robustes face aux défaillances
  • Déploiement continu : Vos applications peuvent être déployées fréquemment et automatiquement
  • Maintenance simplifiée : Vos applications sont plus faciles à maintenir et à faire évoluer

Adaptation à Atlas

La plateforme Atlas facilite l'adoption des 12 facteurs :

  • Configuration : Utilisez les secrets et les variables d'environnement pour configurer vos applications
  • Services externes : Utilisez les ressources Atlas (buckets, bases de données) comme services attachés
  • Processus sans état : Déployez vos applications dans des conteneurs sans état
  • Logs : Utilisez la centralisation des logs pour collecter et analyser les logs de vos applications
  • Parité dev/prod : Utilisez des DeploymentTargets distincts mais similaires pour les différents environnements

Organisation et structure

Structure des dépôts GitOps

  • Nommage cohérent : Utilisez des conventions de nommage cohérentes pour vos fichiers et ressources
  • Organisation par environnement : Structurez vos ressources par environnement (dev, staging, prod)
  • Séparation des préoccupations : Séparez les ressources d'infrastructure des ressources applicatives
  • Documentation : Incluez un README.md dans chaque dossier pour expliquer son contenu et son utilisation

Exemple de structure recommandée pour un dépôt workspace :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
├── README.md
├── resources/
│   ├── buckets/
│   │   ├── app-storage-dev.yaml
│   │   └── app-storage-prod.yaml
│   ├── databases/
│   │   ├── app-db-dev.yaml
│   │   └── app-db-prod.yaml
│   └── deployment-targets/
│       ├── app-dev.yaml
│       ├── app-staging.yaml
│       └── app-prod.yaml
└── deployment-targets/
    ├── app-dev/
    │   ├── deployment.yaml
    │   ├── service.yaml
    │   └── ingress.yaml
    ├── app-staging/
    │   ├── deployment.yaml
    │   ├── service.yaml
    │   └── ingress.yaml
    └── app-prod/
        ├── deployment.yaml
        ├── service.yaml
        └── ingress.yaml

Gestion des environnements

  • Isolation : Utilisez des DeploymentTargets distincts pour chaque environnement
  • Promotion progressive : Déployez d'abord dans les environnements de développement, puis de test, puis de production
  • Configuration par environnement : Adaptez la configuration de chaque environnement selon ses besoins spécifiques
  • Cohérence : Maintenez une cohérence entre les environnements pour faciliter la promotion des changements

Gestion des ressources

Bases de données

  • Choix de l'implémentation : Utilisez CNPG pour le développement et les tests, et Managed (OVH) pour la production
  • Haute disponibilité : Pour la production, définissez replicas à une valeur supérieure à 1
  • Dimensionnement : Dimensionnez correctement vos bases de données en fonction de vos besoins (CPU, mémoire, disque)
  • Sauvegardes : Mettez en place des sauvegardes régulières de vos bases de données
  • Migrations : Utilisez des outils de migration pour gérer l'évolution du schéma de votre base de données

Buckets S3

  • Sécurité : Utilisez l'ACL private sauf si vous avez une raison spécifique de rendre le bucket public
  • Versioning : Activez le versioning si vous avez besoin de conserver l'historique des modifications des fichiers
  • Lifecycle : Mettez en place des politiques de lifecycle pour gérer automatiquement la durée de vie des objets
  • Organisation : Organisez vos fichiers dans le bucket en utilisant des préfixes (similaires à des dossiers)
  • Nommage : Utilisez des noms de bucket uniques et significatifs

DeploymentTargets

  • Isolation : Créez des DeploymentTargets distincts pour chaque environnement ou fonctionnalité
  • Ressources : Adaptez les ressources allouées à chaque DeploymentTarget en fonction de ses besoins
  • Helm : Préférez l'utilisation de helm template pour générer des manifestes plutôt que d'utiliser la fonctionnalité expérimentale des charts dans les DeploymentTargets

Sécurité

Gestion des secrets

  • Vault : Utilisez Vault pour stocker et gérer les secrets
  • External Secrets : Utilisez External Secrets Operator pour récupérer les secrets depuis Vault et les injecter dans vos applications
  • Rotation : Mettez en place une rotation régulière des secrets
  • Principe du moindre privilège : N'accordez que les permissions minimales nécessaires

Exemple d'utilisation d'External Secrets :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: my-secret
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: my-secret
  data:
  - secretKey: username
    remoteRef:
      key: secret/data/my-secret
      property: username
  - secretKey: password
    remoteRef:
      key: secret/data/my-secret
      property: password

Contrôle d'accès

  • RBAC : Utilisez le modèle RBAC (Role-Based Access Control) pour gérer les accès
  • Principe du moindre privilège : N'accordez que les permissions minimales nécessaires
  • Revue régulière : Revoyez régulièrement les permissions accordées
  • Audit : Activez l'audit des accès et des actions

Déploiement et CI/CD

GitOps

  • État souhaité : Définissez l'état souhaité de votre infrastructure et de vos applications dans Git
  • Automatisation : Automatisez le déploiement via ArgoCD
  • Revue de code : Mettez en place des revues de code pour les changements d'infrastructure
  • Tests : Testez les changements avant de les déployer en production

CI/CD

  • Pipelines : Mettez en place des pipelines CI/CD pour automatiser les tests et le déploiement
  • Tests automatisés : Incluez des tests automatisés dans vos pipelines
  • Déploiement progressif : Utilisez des stratégies de déploiement progressif (rolling updates, blue/green, canary)
  • Rollback : Prévoyez des mécanismes de rollback en cas de problème

Exemple de pipeline CI/CD avec GitHub Actions :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
name: CI/CD Pipeline

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

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: '16'
    - name: Install dependencies
      run: npm ci
    - name: Run tests
      run: npm test

  deploy:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Deploy to Atlas
      run: |
        # Commandes pour déployer sur Atlas
        git config --global user.name "GitHub Actions"
        git config --global user.email "actions@github.com"
        git clone https://github.com/your-org/your-workspace-repo.git
        cd your-workspace-repo
        # Mettre à jour les manifestes
        git add .
        git commit -m "Update manifests [skip ci]"
        git push

Surveillance et observabilité

Métriques

  • Grafana : Utilisez Grafana pour visualiser les métriques
  • Dashboards : Créez des dashboards pour surveiller vos applications et ressources
  • Alertes : Configurez des alertes pour être notifié en cas de problème
  • SLOs : Définissez des objectifs de niveau de service (SLOs) et surveillez-les

Logs

  • Centralisation : Centralisez vos logs pour faciliter leur analyse
  • Structuration : Utilisez des logs structurés (JSON) pour faciliter leur traitement
  • Rétention : Définissez une politique de rétention des logs adaptée à vos besoins
  • Analyse : Utilisez des outils d'analyse de logs pour détecter les problèmes

Traçage

  • Distributed tracing : Mettez en place du traçage distribué pour suivre les requêtes à travers les différents services
  • Instrumentation : Instrumentez votre code pour collecter des données de traçage
  • Visualisation : Utilisez des outils de visualisation pour analyser les traces

Performance et scalabilité

Optimisation des ressources

  • Requests et limits : Définissez des requests et limits appropriées pour vos conteneurs
  • Autoscaling : Configurez l'autoscaling pour adapter automatiquement les ressources en fonction de la charge
  • Efficacité : Optimisez vos images Docker pour réduire leur taille et améliorer les temps de démarrage
  • Caching : Utilisez des mécanismes de cache pour améliorer les performances

Haute disponibilité

  • Réplicas : Déployez plusieurs réplicas de vos applications
  • Anti-affinité : Utilisez l'anti-affinité pour répartir les réplicas sur différents nœuds
  • Readiness et liveness probes : Configurez des readiness et liveness probes pour détecter et corriger les problèmes
  • Circuit breakers : Mettez en place des circuit breakers pour éviter les cascades de défaillances

Maintenance et évolution

Mises à jour

  • Versions : Maintenez vos dépendances à jour
  • Changelog : Tenez un changelog des modifications apportées à votre infrastructure
  • Tests de non-régression : Effectuez des tests de non-régression après chaque mise à jour
  • Fenêtres de maintenance : Planifiez des fenêtres de maintenance pour les mises à jour majeures

Documentation

  • Documentation technique : Documentez votre architecture, vos choix techniques et vos procédures
  • Documentation utilisateur : Fournissez une documentation claire pour les utilisateurs de vos applications
  • Runbooks : Créez des runbooks pour les opérations courantes et la résolution des problèmes
  • Mise à jour : Maintenez votre documentation à jour

Collaboration et communication

Travail en équipe

  • Code reviews : Mettez en place des revues de code pour tous les changements
  • Pair programming : Pratiquez le pair programming pour les tâches complexes
  • Knowledge sharing : Organisez des sessions de partage de connaissances
  • Documentation : Documentez les décisions et les processus

Communication

  • Canaux dédiés : Utilisez des canaux de communication dédiés pour les différentes équipes et projets
  • Statut : Communiquez régulièrement sur le statut des projets et des incidents
  • Feedback : Sollicitez et prenez en compte le feedback des utilisateurs et des équipes
  • Transparence : Soyez transparent sur les problèmes et les solutions

Résumé des bonnes pratiques

  • GitOps : Utilisez l'approche GitOps pour gérer votre infrastructure et vos applications
  • Isolation : Isolez vos environnements et vos ressources
  • Automatisation : Automatisez les tests, le déploiement et la surveillance
  • Sécurité : Suivez les bonnes pratiques de sécurité pour protéger vos données et vos applications
  • Documentation : Documentez votre architecture, vos choix techniques et vos procédures
  • Collaboration : Favorisez la collaboration et la communication au sein de votre équipe
  • Amélioration continue : Cherchez constamment à améliorer vos processus et vos pratiques

Paramètres d’affichage

Choisissez un thème pour personnaliser l’apparence du site.