Come Creare una Pipeline CI/CD per le Immagini Docker di CircleCI

Tutorial
Docker

Se stai cercando un modo per testare e distribuire le tue immagini Docker con CircleCI, la creazione di un pipeline CI/CD può farti fare molti progressi nel migliorare la distribuzione del software.

In questo tutorial, imparerai come potenzialmente sviluppare 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 seguirci, assicurati di avere quanto segue:

Correlato:Come installare e utilizzare Docker su Ubuntu (nel mondo reale)

Correlato:Come installare Ubuntu 20.04

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

Prima di passare alla creazione di una pipeline CI/CD, costruirai prima un’immagine Docker basata su un’applicazione Python che visualizza testi su un browser web. Scorrerai brevemente come è costruita l’applicazione, scriverai i casi di test e containerizzerai quindi l’applicazione.

Correlato:Correlato: Guida introduttiva: Funzioni Python per principianti

1. Apri il terminale e esegui il seguente comando per installare Flask e Pytest. Flask è un framework utilizzato per sviluppare applicazioni web in Python mentre Pytest è utilizzato per scrivere codice Python di test. 

pip install flask pytest

Correlato:Come distribuire un’applicazione API Python Flask su Docker

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

mkdir flask-circleci

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

Il codice qui sotto mostra il testo “Benvenuto nella mia app Flask” su una pagina iniziale in un browser.

from flask import Flask

app = Flask(__name__) #crea un'istanza della classe Flask appena importata

@app.route('/')
def main():
    # visualizza una stringa nella pagina iniziale
    return "Welcome to my Flask App"

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

Il codice qui sotto crea un client di test per la tua applicazione.

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

from main import app

def test_main():
		# Crea un client di test per questa applicazione.
    response = app.test_client().get('/') 

		# verifica che il codice di stato della pagina ('/') sia 200
    assert response.status_code == 200 
		# verifica l'istruzione di ritorno alla pagina
    assert response.data == b'Welcome to my Flask App'

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

cd flask-circleci
pytest

Se il test riesce, otterrai un progresso del 100%, come mostrato di seguito.

Running Test for the Project

6. Successivamente, crea un file di testo (requirements.txt) per documentare le tue dipendenze nella directory principale e popola il testo qui sotto. 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 di seguito nel Dockerfile per creare la tua immagine Docker.

Le istruzioni nel Dockerfile eseguono le seguenti operazioni:

  • Crea un file nella tua immagine.
  • Copia tutti i file nella directory corrente (flask-circleci).
  • Esegui il tuo codice
# impostare l'Immagine Base su cui verrà costruita la tua immagine
FROM python:3.8 
# creare una directory chiamata flask-circleci nella root.
# Questa directory conterrà il codice attualmente presente in
RUN mkdir /flask-circleci

# rendere /flask-circleci la directory di lavoro
WORKDIR /flask-circleci

# copiare il tuo file requirements nella directory appena creata
COPY requirements.txt /flask-circleci 

RUN pip install -r requirements.txt

# copiare la directory corrente nel tuo computer locale in /flask-circleci nella tua immagine
ADD . /flask-circleci

EXPOSE 5000

CMD python main.py

Creazione di un Pipeline CI/CD CircleCI

Ora hai la tua immagine Docker pronta, creerai un pipeline CI/CD per testare il tuo codice e, se tutti i test passano, l’immagine Docker verrà caricata su Docker Hub. Docker Hub è un servizio simile a GitHub, ma per le immagini Docker, che ti aiuta a trovare e condividere immagini di container con il tuo team o altri sviluppatori.

Correlato:Come Creare un Pipeline CI CD Jenkins

Per creare il pipeline CI/CD, segui i passaggi seguenti:

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

2. Nella pagina iniziale di Docker Hub, fai clic sull’opzione Crea Repository per creare un repository su Docker Hub.

Creating a Repository

3. Imposta un nome unico per il tuo repository. Questo tutorial utilizza un repository chiamato circleci-tutorial, come mostrato di seguito.

Naming and Creating the Docker Hub Repository

4. Crea un nuovo file (flask-circleci/config.yml) alla radice del tuo progetto, e copia/incolla il codice di seguito nel file config.yml.

Il codice di seguito ottiene un’immagine Python già pronta e la utilizza per installare le dipendenze ed eseguire i test unitari per creare e inviare la tua immagine Docker al tuo repository Docker Hub.

Tipicamente, per un progetto in produzione, vorresti inserire il tuo nome utente e la tua password protetti all’interno di CircleCI o forse in un file .env.

version: 2  # Versione di CircleCI
jobs:
  build:
    docker:
      - image: python:3.8
    steps:
      - checkout

      - run:
        # crea un ambiente virtuale per il tuo progetto,
				# installa le dipendenze al suo interno e esegue i test
          name: Run unit tests
          command: |
            python3 -m venv venv
            . venv/bin/activate
            pip install -r requirements.txt
            pytest
			# Crea un ambiente Docker remoto configurato per eseguire comandi Docker.
      - setup_remote_docker 
       
      - run:
        # installa un client docker che verrà utilizzato per eseguire i comandi docker
          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:
         # Costruisce un'immagine docker da pushare su Docker Hub
				 # Il modello Tag (-t) è sotto, dove CircleCI
				 # per ottenere il Dockerfile dalla directory corrente.
         # <docker_hub_username/docker-hub-password:version>.
          name: Build Docker image
          command: docker build -t khabdrick/circleci-tutorial:v1 .

      - run:
        # Spinge l'immagine Docker che hai creato su Docker Hub.
        # Sostituisci khabdrick/circleci-tutorial:v1 con il
				# <docker_hub_username/docker-hub-password:version> che hai usato per costruire l'immagine sopra
          name: Push to Docker Hub
          command: |
            docker login -u username -p password
            docker push khabdrick/circleci-tutorial:v1

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

git add . # aggiunge le modifiche all'area di staging
git commit -m "update" # committa le tue modifiche
git push # Push su GitHub

Attivazione del Pipeline CircleCI CI/CD

Hai appena creato la tua Pipeline CircleCI CI/CD, ma al momento è lì ferma senza fare molto. Dovrai attivare la tua pipeline configurando un progetto nel tuo account CircleCI.

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

2. Successivamente, fai clic sulla scheda Progetti nel pannello di sinistra e fai clic sul pulsante Configura Progetto sul lato destro del tuo 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.

Setting up a Project

3. Torna alla scheda Dashboard e vedrai lo stato Successo. Lo stato Successo indica che tutto è stato eseguito come previsto e l’immagine è stata caricata nel tuo repository Docker Hub.

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

Viewing Project Status

Di seguito puoi vedere l’elenco dei passaggi che CircleCI ha eseguito per eseguire la pipeline.

Viewing Steps that Ran the Pipeline

4. Infine, torna al tuo repository Docker Hub e vedrai l’immagine che hai caricato su Docker Hub tramite la pipeline CircleCI.

Viewing Pushed circleci docker images in Docker Hub Repository

Caricamento delle modifiche su GitHub per avviare la pipeline CircleCI.

Ora, hai già un pipeline di CircleCI funzionante. Ma forse hai apportato modifiche al tuo progetto. In tal caso, come puoi sapere se la pipeline funziona ancora? Puoi attivare CircleCI inviando le modifiche al tuo repository GitHub e vedere se il test avrà successo.

1. Sul tuo computer locale, sostituisci il codice presente in test_main.py con il seguente codice. Il codice sottostante garantisce intenzionalmente che il test fallisca perché il codice di stato è cambiato da 200 a 400. 

from main import app

def test_main():
		# Crea un client di test per questa applicazione.
    response = app.test_client().get('/') 

		# Asserisci che il codice di stato della pagina ('/') sia 400 quando non lo è, 
		# causando il fallimento del test.
    assert response.status_code == 400 
		# Asserisci la dichiarazione di ritorno nella pagina
    assert response.data == b'Flask App'

2. Successivamente, sostituisci i passaggi nel config.yml che creano l’immagine Docker e la caricano su Docker Hub con il codice seguente.

Nel codice sottostante, stai semplicemente cambiando la versione per assicurarti che solo le nuove modifiche vengano caricate nel 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 username -p password
            docker push khabdrick/circleci-tutorial:v2

3. Esegui i seguenti comandi nella root del tuo progetto per commit e push del codice nel tuo repository GitHub. 

git add . # Aggiunge le modifiche all'area di staging
git commit -m "v2" # Esegue il commit delle modifiche
git push # Push su GitHub

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

Clicca su “build” per vedere i passaggi eseguiti per inviare le modifiche e confermare cosa ha causato il fallimento della build.

Viewing Project Status (Failed)
Showing Failed Tests

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

Come puoi vedere nell’immagine qui sotto, v2 non è stato caricato perché il test è fallito.

Viewing Repository in Docker Hub

Conclusioni

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

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

Source:
https://adamtheautomator.com/circleci-docker-images/