# Stratégies de diffusion modernes avec les actions GitHub **Le principe fondamental: fait des relâchements rapides et sans souffrances , et vousM SK2 vous relâcherez plus fréquemment.** C’est essentiel pour un développement agile. - rapide , des déploiements fiables créent la boucle de rétroaction rapide dont vous avez besoin.M SK2 Lorsque le déploiement est inquiétant ou lente, , les équipes échangent les changements. Ce guide traite des stratégies de diffusion que j’utilise dans la production, depuis les déploiements basés sur un simple étiquette - jusqu’à l’édition multi-package monorepoM SK3 Tous les exemples proviennent du monde réel. [Actions de GitHub](https://docs.github.com/en/actions) les flux de travail dans ce répertoire. [TOC] ## Stratégies de diffusion à un aperçu Avant de se plonger dans les détails, ici's comment les stratégies courantes sont comparéesM SK2 | Stratégie | Suivant le mieux pour | Complexité |----------|----------|------------|-----------| | **Tag-based** | ApplicationsM SK1 sorties explicites | faible | **Direction générale-basée** | Déploiement continu | Moins | **GitFlow** | Publications réglementéesM SK1 versions multiples | élevée | **Trunk- basé sur + Fabrication de drapeaux** | Équipes de vitesse élevéesM SK1Équipe de vitesse moyennes | Établissements matures| Techniques de grande envergure | **Monorepo multi-package** | BibliothèquesM SK1 Bases de code partagées | Équipes de plate-forme moyennes ### Ce qui fonctionne là où **Établissements & Petites équipes**: Démarrer par un tagM SK1 basé sur une branche ou une base de données - déploiement à partir d’une base de donnée M SK3 Garder la simplicité - vous pouvez toujours ajouter de la complexité plus tard MSC5 Trunk- L’élaboration fondée sur des drapeaux de fonction est populaire à l’échelle, mais le surkill pour les petites équipes **Entreprises**: Souvent requis GitFlow ou similaire pour la conformité , pistes d’audit, et gestion des rejetsM SK3 milieux multiples **Des développeurs solitaires**: Tag-based is idealM SK2 Push a tag , de déploiement se produitMST4 Aucune cérémonieM ST5 aucun frais générauxM st6 **Platform/Équipes de bibliothèque**: Besoin de stratégies monoréposées avec une version indépendante par paquet . La version sémantique est cruciale pour les consommateurs en aval ## Tag-Déploiement basé La stratégie la plus simple et la plus fiable. Différents préfixes de balises routent vers différents environnements ou déclenchent différentes actions. ### Environnement ciblage ```yaml on: push: tags: - 'release-*' # Production - 'local-*' # Dev environment ``` ```yaml - name: Build Docker image run: | TAG_NAME=${GITHUB_REF#refs/tags/} if [[ "$TAG_NAME" == local-* ]]; then docker build -t myapp:local . else docker build -t myapp:latest -t myapp:$(date +%s) . fi ``` **Pourquoi cela fonctionne?**: Modèle mental simple , déploiements explicites M SK2 retrait facile par des balises ponctuelles ```bash # Deploy to production git tag release-v2024.12.01 && git push origin release-v2024.12.01 # Deploy to dev git tag local-feature-test && git push origin local-feature-test ``` ### Multi-Version du paquet Pour les monorépos avec plusieurs paquets publiés, utiliser des préfixes de balise pour identifier le paquet à publier: ```yaml # Different workflows, different tag patterns # umami-net.yml on: push: tags: ['umamiv*.*.*'] # e.g., umamiv1.0.5 # fetchextension.yml on: push: tags: ['fetchextension-v*.*.*'] # e.g., fetchextension-v1.2.0 ``` Extraire la version et l’utiliser tout au long: ```yaml - name: Extract version run: echo "VERSION=${GITHUB_REF#refs/tags/umamiv}" >> $GITHUB_OUTPUT - name: Build & Pack run: | dotnet build -c Release -p:Version=${{ steps.version.outputs.VERSION }} dotnet pack -c Release -p:PackageVersion=${{ steps.version.outputs.VERSION }} ``` Pour la version automatique, [MinVer](https://github.com/adamralph/minver) calcule les versions des tags de Git: ```xml umamiv ``` ## Direction générale-Déploiement basé Déployer automatiquement lorsque le code atterre sur des branches particulières. Common dans les démarrages et les équipes rapides -moving teams. ```yaml on: push: branches: [main] # → Production # branches: [develop] # → Staging ``` **Pros**: Aucune étape manuelle **Cons**: Des déploiements accidentels possibles , histoire moins explicite J’utilise une approche hybride - build on branch push (CI verificationM SK2 mais uniquement publier sur les tags: ```yaml on: push: tags: ['scheduler-*'] branches: [main, local] jobs: build: # Always build publish: if: startsWith(github.ref, 'refs/tags/') # Only publish on tags ``` ## Auto-Mises à jour avec la Tour d'observation Pour les déploiements autonomes [Tour d'observation](https://containrrr.dev/watchtower/) tire automatiquement de nouvelles images: ```yaml services: app: image: myapp:latest labels: - "com.centurylinklabs.watchtower.enable=true" watchtower: image: containrrr/watchtower volumes: - /var/run/docker.sock:/var/run/docker.sock command: --interval 300 # Check every 5 minutes ``` **Flux de déploiement**: Push tag → Les actions de GitHub sont construites MSC2 Push to registry MSC3 Watchtower pulls SMC4 Remarque du conteneur MESC5 Total du tempsMSc6 SMSC7 minutes. ## Portes de qualité Les déploiements rapides sont inutiles si vous déployez des bugs. Chaque flux de travail devrait inclure des portes: ```yaml - name: Run tests run: dotnet test --configuration Release - name: Build run: dotnet build --configuration Release # Tests or build fail → workflow stops → no publish ``` Pour les paquets de cadre multiples- , bâtir tous les cibles: ```yaml - run: dotnet build -c Release --framework net8.0 - run: dotnet build -c Release --framework net9.0 ``` ## Publication sans mot de passe avec OIDC Approche moderne - aucun secret pour la rotation , aucune clé pour le déversement M SK2 ```yaml permissions: id-token: write contents: read - uses: NuGet/login@v1 with: user: 'myusername' - run: dotnet nuget push *.nupkg --api-key ${{ steps.login.outputs.NUGET_API_KEY }} ``` GitHub échange son token OIDC pour un short-lived NuGet API keyM SK1 Configurer la confiance sur NuGets.org afin d'en assurer l'activation ## Sécurité de la chaîne d'approvisionnement [Attestations d'artéfacts](https://docs.github.com/en/actions/security-for-github-actions/using-artifact-attestations) démontrer que vos artefacts ont été construits en CI, ne sont pas manipulés avec des instruments de fabrication M SK1 Demande croissante par les entreprises . ```yaml permissions: id-token: write attestations: write - uses: docker/build-push-action@v6 id: push with: push: true tags: myapp:latest - uses: actions/attest-build-provenance@v2 with: subject-name: index.docker.io/myuser/myapp subject-digest: ${{ steps.push.outputs.digest }} push-to-registry: true ``` Les consommateurs vérifient avec: `gh attestation verify oci://index.docker.io/myuser/myapp:latest --owner myuser` Il s'agit de : [Niveau SLSA 2](https://slsa.dev/spec/v1.0/levels). Pour l'utilisation du niveau 3, [Les flux de travail réutilisables](https://docs.github.com/en/actions/sharing-automations/reusing-workflows). ## Vue préalable des environnements Les équipes ont besoin d’intervenants pour prévoir les changements avant la fusion. **Approche d'entreprise** - Direction générale-environnements de prévision basés sur : ```yaml on: pull_request: types: [opened, synchronize] - run: | BRANCH=$(echo ${{ github.head_ref }} | sed 's/[^a-zA-Z0-9]/-/g') docker build -t myapp:preview-$BRANCH . # Deploy to k8s namespace, cloud platform, etc. ``` **Startup/approche solaire** - Tunnelez votre machine locale: ```bash # Cloudflare Tunnel (free) cloudflared tunnel run --url http://localhost:5000 my-preview # → https://my-preview.cfargotunnel.com ``` Ou utiliser [Garde des câbles](https://www.wireguard.com/) VPN pour l'accès interne de votre équipe à votre machine dev. ## Conseils pratiques **Nettoyage des balises**: Les balises de Git restent toujours sur place ```bash git tag -d old-test-tag # Delete local git push origin :refs/tags/old-test-tag # Delete remote ``` **Conventions de désignation**: Soyez cohérentsM SK1 - `release-YYYY.MM.DD` pour la production - `local-feature-name` pour dev - `packagev1.2.3` pour les bibliothèques **Secrets**: Entrepôt en [Secrets de GitHub](https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions), jamais dans le code . Les secrets requis sont habituellement - `DOCKER_HUB_ACCESS_TOKEN` - `NUGET_API_KEY` (ou utiliser OIDC) - `NPM_TOKEN` **Développement de Monorepo**: Utiliser les références de projet pendant la mise au point ```xml ``` ## Passer à Kubernetes Les mêmes principes,outils différents: | Docker Compose | Kubernetes | |----------------|------------| | Tour d’observation | [ArgoCD](https://argo-cd.readthedocs.io/) / [Flux](https://fluxcd.io/docs/) | | dockerM SK1compose.environnements XML |espaces de nom | | Remarrage du conteneur | Déploiement roulant | Retour manuel | Revol GitOps | ## Résumé 1. **Démarrer simple**: Tag-le déploiement basé couvre la plupart des besoins 2. **Ajouter de la complexité au besoin**: Direction généraleM SK1 fondée, multiMSC3 environnemental , attestations 3. **Automatiser les portes de qualité**: Les essais doivent réussir avant la publication 4. **Activer le retournement**: Tag Timestamped ou histoire de GitOps 5. **Sécuriser votre pipeline**: OIDC pour les secrets, attestations de provenance 6. **Coordonner votre contexte**: Solo dev Les flux de travail présentés ici fonctionnent dans ce répertoire - vérification `.github/workflows/` pour les mises en œuvre complètes. **Remarque**: Rapide , Des déploiements fiables sont la base d’un développement agileM SK2 Investir dans votre pipeline de diffusion tôt