Automatisez les processus de création, de test et de déploiement avec les actions GitHub

Ce projet est un exemple rapide de projet qui démontre l'automatisation du processus de création, de test et de déploiement d'une application dans un environnement de test lors du push vers la branche principale.

Pour démontrer adéquatement le pipeline CI/CD, nous allons créer un projet Python simple avec un minimum de code, puis l'intégrer dans GitHub Actions.

Créer un projet Python simple

Comme je l'ai dit plus tôt, nous allons créer un projet simple que nous utiliserons dans notre pipeline. J'ai choisi de faire cela en python sans raison particulière, vous pouvez utiliser n'importe quel autre langage de programmation de votre choix, le principal de ce projet est de démontrer le pipeline.

Créer un dossier de projet

Alors allez-y, créez le dossier du projet et naviguez dans ce dossier :

mkdir automated-testing
cd automated-testing

Écrire le dossier de candidature

Nous allons maintenant écrire l'application Python simple. Créez un nouveau fichier app.py dans le dossier du projet.

touch app.py

Ajoutez le bloc de code ci-dessous au fichier :

def hello():
  return "Hello, World!"

if __name__ == "__main__":
  print(hello())

Il s'agit d'une fonction python "Hello world" très simple qui sert d'exemple de fonctionnalité de base qui peut être testée dans le pipeline CI.

def hello() définit une fonction nommée hello qui ne prend aucun argument. Lorsque cette fonction est appelée, elle renvoie la chaîne "Hello, World!".

if __name__ == "__main__" est une construction Python standard utilisée pour garantir que certains codes ne s'exécutent que lorsque le fichier est exécuté directement (et non lorsqu'il est importé en tant que module). Il fait office de point d'entrée pour le script.

Lorsque app.py est exécuté directement (par exemple, en exécutant python app.py), le script appellera la fonction hello() et imprimera le résultat, qui est "Hello, World!".

Créez un fichier d'exigences.

Un projet typique aurait des dépendances et dans un projet Python, elles sont généralement définies dans le fichier Requirements.txt.

Créer un nouveau fichier conditions.txt

touch requirements.txt

Ajoutez ceci au fichier :

pytest

Créer un test unitaire

Nous allons maintenant ajouter un fichier de test de base, test_app.py, pour tester la fonction dans app.py. Ajoutez ce qui suit au fichier :

from app import hello

def test_hello():
  assert hello() == "Hello, World!"

Nous sommes maintenant prêts à créer notre pipeline.

Configurer les actions GitHub pour CI/CD

Pour configurer les actions GitHub, nous devons créer un dossier .github/workflows dans notre dépôt, c'est ainsi que nous informons GitHub du pipeline CI/CD dans notre dépôt.

Créer un nouveau fichier :

mkdir -p .github/workflows

Vous pouvez avoir plusieurs pipelines dans un seul dépôt, alors créez un fichier proj.yml dans le dossier .github/workflows. C'est ici que nous définirons les étapes de construction, de test et de déploiement de notre projet Python.

Ajoutez le code ci-dessous à votre fichier :

name: Build, Test and Deploy

# Trigger the workflow on pushes to the main branch
on:
  push:
    branches:
      - main

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
    # Checkout the code from the repository
    - name: Checkout repo
      uses: actions/checkout@v4

    # Set up Python environment
    - name: Setup Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.x'

    # Install dependencies
    - name: Install Dependecies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt

    # Build (this project deosn't require a build but we will simulate a build by creating a file)
    - name: Build Project
      run: |
        mkdir -p build
        # Simulate build output by creating a file
        touch build/output_file.txt

    # Run tests using pytest
    - name: Run tests
      run: 
        pytest

    # Upload the build output as an artifact (we created a file in the build step to simulate an artifact)
    - name: Upload build artifact
      uses: actions/upload-artifact@v4
      with:
        name: build-artifact
        path: build/

  deploy:
    runs-on: ubuntu-latest
    needs: build-and-test
    if: success()

    steps:
    # Download the artifact from the build stage
    - name: Download build artifact
      uses: actions/download-artifact@v4
      with:
        name: build-artifact
        path: build/

    - name: Simulate Deployment
      run: |
        echo "Deploying to staging..."
        ls build/

Breakdown of the CI/CD Pipeline Steps

• Trigger on Push to main: The pipeline is triggered whenever there is a push to the main branch.

• Checkout Code: This step uses GitHub’s checkout action to pull our code from the repository.

• Set Up Python: The pipeline sets up a Python environment on the CI runner (GitHub's virtual machine), ensuring that the correct Python version is used.

• Install Dependencies: It installs the required dependencies for our Python project (pytest in this case). This dependency was just added as an example of when a project has dependencies as this particular sample python application does not require any.

• Build: This stage was also just added for demonstration purposes, supposing this was a JavaScript/Node.js project this is where we would run the npm run build command and this will create an artifact we can upload and use in the deploy stage. Since this is a python project and it doesn't really require a build, we will create a file and folder in this stage. The file will serve as our artifact for the deploy stage.

• Run Tests: It runs the tests using pytest to validate the code.

• Upload Build Artifact: After running the tests, the build-and-test stage creates and saves a build artifact (in this case, a simulated output_file.txt in the build folder from the build step). The action upload-artifact is used to store this artifact. You can replace this with whatever actual build output your project creates.

• Deploy Stage: Our application will only be deployed if the test was successful which is why I have added the conditionals needs and if. Using “needs” we can require that the deploy job won’t even run unless the test job is successful. The download-artifact action retrieves the build artifact and the last step "Simulate Deployment" simulates deployment by printing a message and lists the artifact. If this was a live project we would have the actual deployment commands to deploy to a real staging environment here. You can replace the echo and ls commands with actual deployment commands (e.g., deploying to a cloud platform). This approach ensures that the output from the build-and-test stage is properly passed to the deploy stage, simulating how a real deployment would work with build artifacts.

Push to GitHub

If you haven't already, you need to initialize a git repository using the commands below:

git init
git add .
git commit -m "Create project as well as CI/CD pipeline"

Now we push to GitHub. Create a GitHub repository and push your code using the below commands:

git remote add origin <your-repo-url>
git push -u origin main

Verify the Pipeline

After pushing the code, you can visit the Actions tab in your GitHub repository. You should see the pipeline triggered, running the steps defined in your proj.yml file.

If everything is set up correctly, the pipeline will build, test, and simulate deployment. You can changes things around in your project and make new pushes to see the the pipeline works, create errors intentional so you can see how the pipeline works when the tests fail.

On a successful run this is how your Actions tab should look.

And that's it, this setup provides a working example of a CI/CD pipeline for a very basic Python project. If you found this helpful, please share with your connection and if you have any questions, do not hesitate to drop the question in the comments.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!