Come creare una pipeline CI/CD per le immagini Docker CircleCI

Se stai cercando un modo per testare e distribuire le tue immagini Docker CircleCI, la creazione di una pipeline CI/CD può richiedere molto per migliorare la distribuzione del software.

In questo tutorial imparerai come sviluppare potenzialmente una pipeline CI/CD per la tua immagine Docker utilizzando CircleCI.

Continua a leggere e distribuisci le tue immagini Docker, solo se superano il test!

Prerequisiti

Questo tutorial sarà una dimostrazione pratica. Se desideri continuare, assicurati di avere quanto segue:

• Un GitHub account e repository GitHub che è già impostato.

• Un account CircleCI collegato al tuo account GitHub.

• Un account Docker Hub.

• Docker installato.

• Una macchina Linux:questo tutorial utilizza Ubuntu 20.04.3 LTS.

Creazione di un'immagine Docker di un'applicazione basata su Python

Prima di passare alla creazione di una pipeline CI/CD, creerai prima un'immagine Docker basata su un'applicazione Python che visualizza i testi su un browser web. Analizzerai brevemente come viene creata l'applicazione, scriverai i casi di test per l'applicazione e quindi contenitorizzerai l'applicazione.

1. Apri il tuo terminale ed esegui il seguente comando per install Flask e Pytest. Flask è un framework utilizzato per creare applicazioni Web in Python mentre Pytest viene utilizzato per scrivere test di codice Python.

pip install flask pytest

2. Quindi, crea una directory del progetto con il tuo nome preferito, ma la directory del progetto si chiama flask-circleci in questa demo. Questa directory è dove memorizzerai le tue risorse per questo tutorial.

mkdir flask-circleci

3. Crea un file chiamato flask-circleci/main.py e compilare il codice seguente.

Il codice seguente mostra il testo "Benvenuto nella mia app Flask" su una home page in un browser.

from flask import Flask

app = Flask(__name__) #create an instance of the Flask class you just imported

@app.route('/')
def main():
    # display a string in the home page
    return "Welcome to my Flask App"

4. Ora crea un altro file chiamato flask-circleci/test_main.py e copia/incolla il codice seguente.

Il codice seguente crea un client di prova per la tua applicazione.

Pytest richiede che il nome del file di test inizi con test_ come illustrato di seguito.

from main import app

def test_main():
		# Creates a test client for this application.
    response = app.test_client().get('/') 

		# assert the stutus code of the page('/') is 200
    assert response.status_code == 200 
		# assert the return statement to the page
    assert response.data == b'Welcome to my Flask App' 

5. Esegui i seguenti comandi per accedere alla directory del tuo progetto (flask-circleci ), esegui il test per il tuo progetto.

cd flask-circleci
pytest

Se il test ha esito positivo, otterrai un progresso del 100%, come mostrato di seguito.

6. Quindi, crea un file di testo (requirements.txt ) per documentare le tue dipendenze nella directory principale e compilare il testo sottostante. Questo file è essenziale durante la creazione dell'immagine Docker in modo che funzioni correttamente.

Flask==2.0.3
pytest==6.2.5

7. Infine, crea un nuovo file (flask-circleci/Dockerfile) e scrivi le istruzioni seguenti nel Dockerfile per creare la tua immagine Docker.

Le istruzioni nel Dockerfile eseguire le seguenti operazioni:

• Crea un file nella tua immagine.

• Copia tutti i file nei file nella directory corrente (flask-circleci ).

• Esegui il tuo codice

# set the Base Image from which your image will be built on
FROM python:3.8 
# create a directory called flask-circleci in root. 
# This directory will contain the code which currently resides in
RUN mkdir /flask-circleci

# make /flask-circleci the working directory
WORKDIR /flask-circleci

# copy your requirements file to the directory you just created
COPY requirements.txt /flask-circleci 

RUN pip install -r requirements.txt

# copy the current directory in you local machine to /flask-circleci in your image
ADD . /flask-circleci

EXPOSE 5000

CMD python main.py

Creazione di una pipeline CI/CD CircleCI

Ora che hai la tua immagine Docker pronta, creerai una pipeline CI/CD per testare il tuo codice e, se tutti i test superano l'immagine Docker e vengono inviati a Docker Hub. Docker Hub è un servizio come GitHub, ma per le immagini Docker, che ti aiuta a trovare e condividere immagini di container con il tuo team o altri sviluppatori.

Per creare la pipeline CI/CD, procedi nel seguente modo:

1. Apri il tuo browser web preferito e accedi al tuo account Docker Hub.

2. Nella home page di Docker Hub, fare clic su Crea repository opzione per creare un repository su Docker Hub.

3. Imposta un nome univoco per il tuo repository. Questo tutorial utilizza un repository chiamato tutorial circolare , come mostrato di seguito.

4. Crea un nuovo file (flask-circleci/config.yml) nella radice del tuo progetto e copia/incolla il codice seguente in config.yml file.

Il codice seguente ottiene un'immagine Python già pronta e la utilizza per installare le dipendenze ed eseguire gli unit test per creare e inviare l'immagine Docker al Docker Hub del repository.

In genere, per un progetto live, vorresti mettere il tuo nome utente e password protetti all'interno di CircleCI o magari in un file .env.

version: 2  # Version of CircleCI
jobs:
  build:
    docker:
      - image: python:3.8
    steps:
      - checkout

      - run:
        # creates a virtual environment for you project, 
				# install dependencies in it and run tests
          name: Run unit tests
          command: |
            python3 -m venv venv
            . venv/bin/activate
            pip install -r requirements.txt
            pytest
			# Creates a remote Docker environment configured to execute Docker commands.
      - setup_remote_docker 
       
      - run:
        # installs a docker client that will be used to run the docker commands
          name: Install Docker client
          command: |
            set -x
            VER="17.03.0-ce"
            curl -L -o /tmp/docker-$VER.tgz https://get.docker.com/builds/Linux/x86_64/docker-$VER.tgz
            tar -xz -C /tmp -f /tmp/docker-$VER.tgz
            mv /tmp/docker/* /usr/bin
      - run:
         # Builds a docker image to push to Docker Hub
				 # Tag (-t) pattern is below, where CircleCI 
				 # to get the Dockerfile from the current directory.
         # <docker_hub_username/docker-hub-password:version>.
          name: Build Docker image
          command: docker build -t khabdrick/circleci-tutorial:v1 .

      - run:
        # Pushes the Docker image you created to the Docker Hub.
        # Replace khabdrick/circleci-tutorial:v1 with the 
				# <docker_hub_username/docker-hub-password:version> you used to build the image above
          name: Push to Docker Hub
          command: |
            docker login -u unsername -p password
            docker push khabdrick/circleci-tutorial:v1

5. Infine, esegui i seguenti comandi sulla radice del tuo progetto per commit e push il codice (flask-circleci/config.yml ) nel tuo repository GitHub.

git add . # adds changes to staging area
git commit -m "update" # commits your changes
git push # Push to GitHub

Attivazione della pipeline CI/CD CircleCI

Hai appena creato la tua pipeline CI/CD CircleCI, ma in questo momento è semplicemente lì e non fa molto. Dovrai attivare la tua pipeline impostando un progetto nel tuo account CircleCI.

1. Accedi al tuo account CircleCI con il tuo account GitHub sul tuo browser web.

2. Quindi, fai clic su Progetti scheda nel pannello di sinistra e fai clic su Imposta progetto pulsante sul lato destro del progetto per attivare la pipeline CircleCI sul progetto.

Dato che hai effettuato l'accesso a CircleCI con il tuo account GitHub, i tuoi progetti si sincronizzano con CircleCI, come nell'immagine qui sotto.

3. Torna alla Dashboard scheda e vedrai il Successo stato. Il successo status indica che tutto è stato eseguito come previsto e l'immagine è stata inviata al repository Docker Hub.

Fai clic su build per vedere tutti i passaggi eseguiti nella pipeline.

Di seguito è possibile visualizzare l'elenco dei passaggi eseguiti da CircleCI per eseguire la pipeline.

4. Infine, torna al tuo repository Docker Hub e vedrai l'immagine che hai inviato a Docker Hub attraverso la pipeline CircleCI.

Inserire le modifiche su GitHub per attivare la pipeline CircleCI

A questo punto, hai già una pipeline CircleCI funzionante. Ma forse hai apportato modifiche al tuo progetto. In tal caso, come sapresti che il gasdotto funziona ancora? Puoi attivare CircleCI inviando le modifiche al tuo repository GitHub e vedere se il test avrà esito positivo.

1. Sul tuo computer locale, sostituisci il codice che hai in test_main.py con il codice qui sotto. Il codice riportato di seguito garantisce che il test abbia esito negativo perché il codice di stato è cambiato da 200 a 400 .

from main import app

def test_main():
		# Creates a test client for this application.
    response = app.test_client().get('/') 

		# assert the status code of the page('/') is 400 when it isn't, 
		# causing the test to fail.
    assert response.status_code == 400 
		# assert the return statement ton the page
    assert response.data == b'Flask App' 

2. Quindi, sostituisci i steps nel config.yml che crea l'immagine Docker e la invia a Docker Hub con il codice seguente.

Nel codice seguente, stai semplicemente modificando la versione per assicurarti che solo le nuove modifiche vengano inviate al tuo repository GitHub.

      - run:
          name: Build Docker image
          command: docker build -t khabdrick/circleci-tutorial:v2 .

      - run:
          name: Push to DockerHub
          command: |
            docker login -u khabdrick -p Muhammed-1998
            docker push khabdrick/circleci-tutorial:v2

3. Esegui i seguenti comandi sulla radice del tuo progetto per commit e push il codice nel tuo repository GitHub.

git add . # adds changes to staging area
git commit -m "v2" # commits your changes
git push # Push to GitHub

4. Ora vai alla dashboard di CircleCI e vedrai che la build Fallita , come mostrato di seguito.

Fai clic su build per vedere i passaggi eseguiti per eseguire il push delle modifiche e confermare cosa ha causato il fallimento della build.

5. Infine, vai al repository Docker Hub e conferma che le modifiche non sono state inviate.

Come puoi vedere nell'immagine qui sotto, la v2 non è stata caricata perché il test non è riuscito.

Conclusione

Durante questo tutorial, hai imparato a scrivere test e a Dockerizzare la tua applicazione Python. Hai creato una pipeline CI/CD con CircleCI che esegue il test per la tua applicazione e invia l'immagine Docker a Docker Hub.

A questo punto, hai già una conoscenza di base dello sviluppo di una pipeline CI/CD con CircleCI. Ora, come intendi utilizzare questa nuova conoscenza? Forse stai creando una pipeline CI/CD che distribuisce la tua immagine Docker su Heroku?