26 posts tagged with "Devops"

GitHub Container Registry (GHCR) est un service d'hébergement de packages logiciels proposé par GitHub, permettant aux utilisateurs de stocker des packages privés ou publics et de les utiliser comme dépendances dans leurs projets. Compatible avec plusieurs langages de programmation, GitHub Packages propose des registres pour des gestionnaires de packages tels que npm, RubyGems, Maven, Gradle, Docker, et NuGet. L'authentification sur GitHub Packages se fait exclusivement via un "personal access token (classic)". Les utilisateurs doivent disposer de ce token pour effectuer des opérations telles que la publication, l'installation et la suppression de packages, qu'ils soient publics, privés ou internes. Pour les packages privés, GitHub Packages applique des limites de stockage et de transfert de données en fonction du plan du compte. La gestion des packages peut être réalisée à travers l'interface utilisateur GitHub ou via l'API REST. Des webhooks peuvent également être configurés pour suivre des événements liés aux packages, comme la publication ou la mise à jour.

Le débogage des conteneurs Docker est une compétence essentielle pour tout développeur ou administrateur système travaillant avec des environnements conteneurisés. Docker offre une variété de commandes et d'options pour aider à identifier et résoudre les problèmes qui peuvent survenir dans les conteneurs. Dans cet article, nous allons explorer certaines des commandes de base et des techniques avancées pour déboguer les conteneurs Docker.

< !--truncate-->

Commandes de base pour le débogage​

docker ps​

La commande docker ps est utilisée pour lister les conteneurs en cours d'exécution. Vous pouvez utiliser l'option -a pour afficher tous les conteneurs, qu'ils soient en cours d'exécution ou arrêtés.

docker ps
docker ps -a

docker logs​

La commande docker logs permet de visualiser les journaux d'un conteneur. Cela peut être très utile pour identifier les erreurs ou les comportements inattendus.

docker logs <container_id>

Vous pouvez également utiliser le nom du conteneur à la place de l'ID.

docker exec​

La commande docker exec permet d'exécuter des commandes à l'intérieur d'un conteneur en cours d'exécution. Cela peut être utile pour naviguer dans le système de fichiers du conteneur, vérifier les configurations ou exécuter des scripts de diagnostic.

docker exec -it <container_id> /bin/bash

docker inspect​

La commande docker inspect fournit des informations détaillées sur un conteneur ou une image Docker. Cela inclut des détails sur la configuration, les réseaux, les volumes et plus encore.

docker inspect <container_id>

Techniques avancées de débogage​

Utilisation de docker run avec des options​

La commande docker run peut être utilisée avec diverses options pour faciliter le débogage. Par exemple, l'option -d permet de démarrer un conteneur en mode détaché, tandis que l'option -p permet de mapper les ports entre l'hôte et le conteneur.

docker run -d -p 8080:80 <image_name>

Redémarrage des conteneurs​

Les commandes docker start et docker stop permettent de redémarrer les conteneurs. Cela peut être utile si vous avez apporté des modifications à la configuration du conteneur et que vous souhaitez les appliquer.

docker stop <container_id>
docker start <container_id>

Nommage des conteneurs​

Lorsque vous créez un conteneur, vous pouvez lui attribuer un nom pour faciliter son identification. Cela peut être fait en utilisant l'option --name avec la commande docker run.

docker run --name my_container <image_name>

Conclusion​

Le débogage des conteneurs Docker peut sembler complexe au début, mais en utilisant les commandes et techniques appropriées, vous pouvez rapidement identifier et résoudre les problèmes. Les commandes de base comme docker ps, docker logs, docker exec et docker inspect sont essentielles pour tout développeur ou administrateur système travaillant avec Docker. En combinant ces commandes avec des techniques avancées comme l'utilisation de docker run avec des options et le redémarrage des conteneurs, vous pouvez améliorer considérablement votre efficacité dans le débogage des conteneurs Docker.

Les conteneurs Docker sont des unités logicielles légères et portables qui encapsulent une application et ses dépendances dans une image. Ces images sont composées de plusieurs couches, souvent basées sur une distribution Linux légère comme Alpine, pour minimiser la taille. Les conteneurs permettent de maintenir des applications isolées et cohérentes, indépendamment de l'environnement d'exécution.

Docker est de plus en plus populaire car il résout des problèmes courants dans le développement logiciel, en particulier ceux liés à la configuration de l'environnement et à la compatibilité. Les applications modernes utilisent souvent une combinaison de différentes technologies, chacune avec des dépendances de version spécifiques. Ces applications doivent fonctionner de manière cohérente dans divers environnements (développement, test, production), qui peuvent différer en termes de système d'exploitation, de version et de matériel. Sans Docker, chaque environnement doit être configuré avec les versions correctes des services, ce qui entraîne des problèmes de compatibilité et des configurations complexes.

L'objectif est de créer une architecture CI/CD complète pour un projet de développement adressant une technologie (par exemple ROS). Cette architecture doit être :

• facilement réutilisable dans d'autres projets
• éviter la duplication de code
• maintenable et évolutive aisément
• applicable à d'autres projets

Actions Runner Controller (ARC) est un opérateur de Kubernetes qui orchestre et gère les runners auto-hébergés pour les actions GitHub.

Un runner est une machine virtuelle ou physique qui exécute des jobs dans un workflow. Les runners peuvent être hébergés par GitHub ou auto-hébergés. Les runners hébergés par GitHub sont exécutés dans un environnement de cloud partagé et sont gérés par GitHub et peuvent entrainer des surcouts. Les runners auto-hébergés sont exécutés sur une machine que vous possédez et gérez.

Exemple de création et d'utilisation d'une action GitHub​

Voici un exemple de création et d'utilisation d'une action GitHub pour automatiser le déploiement d'une application Node.js.

1. Créez un fichier action.yml dans le répertoire .github/actions/deploy de votre dépôt avec le contenu suivant :

name: 'Deploy Node.js App'
description: 'Deploy a Node.js application to a remote server'
inputs:
  server:
    description: 'The remote server to deploy to'
    required: true
  username:
    description: 'The username to use for the deployment'
    required: true
  password:
    description: 'The password to use for the deployment'
    required: true
runs:
  using: 'composite'
  steps:
    - name: Checkout code
      uses: actions/checkout@v4
    - name: Install dependencies
      run: npm install
    - name: Build application
      run: npm run build
    - name: Deploy application
      run: |
        sshpass -p ${{ inputs.password }} ssh ${{ inputs.username }}@${{ inputs.server }} 'mkdir -p /var/www/myapp'
        sshpass -p ${{ inputs.password }} scp -r ./build/* ${{ inputs.username }}@${{ inputs.server }}:/var/www/myapp

2. Créez un fichier deploy.yml dans le répertoire .github/workflows de votre dépôt avec le contenu suivant :

name: Deploy Node.js App

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Deploy application
        uses: ./.github/actions/deploy
        with:
          server: ${{ secrets.DEPLOY_SERVER }}
          username: ${{ secrets.DEPLOY_USERNAME }}
          password: ${{ secrets.DEPLOY_PASSWORD }}

Dans cet exemple, l'action Deploy Node.js App est utilisée pour déployer une application Node.js sur un serveur distant. L'action est déclenchée à chaque fois qu'un push est effectué sur la branche main. Les informations de déploiement (serveur, nom d'utilisateur et mot de passe) sont stockées dans les secrets du dépôt pour des raisons de sécurité.

Les actions GitHub permettent d'automatiser, personnaliser et exécuter un flux de travail directement depuis votre dépôt. Avec les actions GitHub, il est possible de créer des tâches personnalisées pour automatiser un flux de travail, partager et découvrir des actions pour effectuer des tâches spécifiques.

Exemple d'intégration des actions GitHub dans les workflows​

Voici un exemple d'intégration des actions GitHub dans un workflow pour automatiser le déploiement d'une application Node.js.

Un workflow est l'élément central de GitHub Actions. Il s'agit d'un processus automatisé composé de jobs et de steps qui s'exécutent sur des runners. Les workflows sont déclenchés par des événements, tels que des pushs, des pull requests, des forks, etc.