Quali sono le migliori pratiche per implementare PySpark su AWS?

Le migliori strategie per implementare PySpark su AWS

Introduzione

Nell’ambito dei big data e dell’analisi avanzata, PySpark si è affermato come uno strumento potente per elaborare grandi set di dati e analizzare dati distribuiti. L’utilizzo di PySpark su applicazioni AWS nel cloud può rappresentare una svolta, offrendo scalabilità e flessibilità per compiti intensivi di dati. Amazon Web Services (AWS) fornisce una piattaforma ideale per tali implementazioni e, se combinato con i container Docker, diventa una soluzione fluida ed efficiente.

Tuttavia, l’implementazione di PySpark su un’infrastruttura cloud può essere complessa e intimidatoria. Le complessità dell’allestimento di un ambiente di calcolo distribuito, la configurazione dei cluster Spark e la gestione delle risorse spesso scoraggiano molti dall’utilizzare il loro pieno potenziale.

Obiettivi di apprendimento

• Apprendere i concetti fondamentali di PySpark, AWS e Docker, garantendo una solida base per l’implementazione di cluster PySpark nel cloud.
• Seguire una guida completa passo-passo per configurare PySpark su AWS usando Docker, comprese la configurazione di AWS, la preparazione delle immagini Docker e la gestione dei cluster Spark.
• Scoprire strategie per ottimizzare le prestazioni di PySpark su AWS, compresa la monitoraggio, la scalabilità e il rispetto delle migliori pratiche per sfruttare al massimo i flussi di elaborazione dei dati.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

• Top 10 Agenzie di Personale Remoto da Tenere d’Occhio nel 2024
• Da adolescente adorava i videogiochi. Ora sta utilizzando l’intelligenza artificiale per cercare di debellare la malaria.
• OpenAI guida l’IA di prossima generazione con GPT-4 Turbo

Prerequisiti

Prima di intraprendere il percorso per implementare PySpark su AWS usando Docker, assicurati di avere i seguenti prerequisiti:

🚀 Installazione locale di PySpark: Per sviluppare e testare applicazioni PySpark, è essenziale avere PySpark installato sul tuo computer locale. Puoi installare PySpark seguendo la documentazione ufficiale del tuo sistema operativo. Questa installazione locale sarà il tuo ambiente di sviluppo, che ti permetterà di scrivere e testare il codice PySpark prima di implementarlo su AWS.

🌐 Account AWS: Dovrai avere un account AWS (Amazon Web Services) attivo per accedere all’infrastruttura cloud e ai servizi necessari per l’implementazione di PySpark. Puoi registrarti sul sito web di AWS se non hai un account AWS. Sii pronto a fornire le tue informazioni di pagamento, anche se AWS offre un tier gratuito con risorse limitate per i nuovi utenti.

🐳 Installazione di Docker: Docker è un componente fondamentale in questo processo di implementazione. Installa Docker sul tuo computer locale seguendo le istruzioni di installazione per il sistema operativo Ubuntu. I container Docker ti permetteranno di incapsulare e implementare in modo coerente le tue applicazioni PySpark.

Windows

1. Visita il
2. Scarica l’installer di Docker Desktop for Windows.
3. Fai doppio clic sull’installer per avviarlo.
4. Segui le istruzioni dell’installazione guidata.
5. Una volta installato, avvia Docker Desktop dalle tue applicazioni.

macOS

1. Vai al
2. Scarica l’installer di Docker Desktop for Mac.
3. Fai doppio clic sull’installer per aprirlo.
4. Trascina l’icona di Docker nella tua cartella Applicazioni.
5. Avvia Docker dalle tue Applicazioni.

Linux (Ubuntu)

1. Apri il tuo terminale e aggiorna il tuo gestore dei pacchetti:

sudo apt-get update

2. Installa le dipendenze necessarie:

sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

3. Aggiungi la chiave GPG ufficiale di Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg |  sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

4. Configurare il repository Docker:

echo "deb [signed-by=/usr/share/keyrings/docker-archive-keyring.gpg]https://download.docker.com/linux/ubuntu $(lsb_release -cs) stabile" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

5. Aggiornare nuovamente l’indice dei pacchetti:

sudo apt-get update

6. Installare Docker:

sudo apt-get install -y docker-ce docker-ce-cli containerd.io

7. Avviare e abilitare il servizio Docker:

sudo systemctl start dockersudo systemctl enable docker

8. Verificare l’installazione:

sudo docker --version

**** Aggiungere linee di divisione in una sola linea

Guarda un tutorial video sull’installazione di Docker

Configurazione di AWS

Amazon Web Services (AWS) è la base della nostra distribuzione di PySpark e utilizzeremo due servizi essenziali, Elastic Container Registry (ECR) e Elastic Compute Cloud (EC2), per creare un ambiente cloud dinamico.

Registrazione del conto AWS

Se ancora non l’hai fatto, vai alla pagina di registrazione AWS per creare un account. Segui il processo di registrazione, fornisce le informazioni necessarie e sii pronto con i dettagli di pagamento se desideri esplorare oltre l’AWS Free Tier.

AWS Free Tier

Per chi è nuovo in AWS, approfitta dell’AWS Free Tier, che offre risorse e servizi limitati senza alcun costo per 12 mesi. Questo è un ottimo modo per esplorare AWS senza sostenere spese.

Chiave di accesso AWS e chiave segreta

Avere un Access Key ID e una Secret Access Key è necessario per interagire con AWS in modo programmato. Segui questi passaggi per generarli:

• Accedi alla Console di Gestione AWS.
• Naviga al servizio Identity & Access Management (IAM).
• Fai clic su “Utenti” nel riquadro di navigazione a sinistra.
• Crea un nuovo utente o seleziona uno esistente.
• Sotto la scheda “Credenziali di sicurezza”, genera una chiave di accesso.
• Annota l’Access Key ID e la Secret Access Key, perché le useremo successivamente.
• Dopo aver cliccato su utente

Elastic Container Registry (ECR)

ECR è un servizio di registro di container Docker gestito da AWS. Sarà il nostro repository per la memorizzazione delle immagini Docker. Puoi configurare il tuo ECR seguendo questi passaggi:

• Nella Console di Gestione AWS, vai al servizio Amazon ECR.
• Crea un nuovo repository, dagli un nome e configura le impostazioni del repository.
• Annota l’URI del tuo repository ECR; ne avrai bisogno per il caricamento delle immagini Docker.

Elastic Compute Cloud (EC2)

EC2 fornisce capacità di calcolo scalabile nel cloud e ospiterà le tue applicazioni PySpark. Per configurare un’istanza EC2:

• Nella Console di Gestione AWS, vai al servizio EC2.
• Avvia una nuova istanza EC2, scegliendo il tipo di istanza adatto al tuo carico di lavoro.
• Configura i dettagli dell’istanza e le opzioni di archiviazione.
• Crea o seleziona una coppia di chiavi esistenti per connetterti in modo sicuro alla tua istanza EC2.

“““” QUI IMPORTANTE DOPO ATTACCARE I GRUPPI DI SICUREZZA “““”

Guarda un tutorial video

Memorizzazione dei valori di configurazione AWS per il futuro uso

AWS_ACCESS_KEY_ID: YOURSAMPLEACCESSKEYAWS_ECR_LOGIN_URI: 123456789012.dkr.ecr.region.amazonaws.comAWS_REGION: us-east-1AWS_SECRET_ACCESS_KEY: YOURSAMPLESECRETACCESSKEY12345ECR_REPOSITORY_NAME: nome-del-tuo-repository-ecr

Configurazione dei segreti e delle variabili di GitHub

Ora che hai i tuoi valori di configurazione AWS pronti, è il momento di configurarli in modo sicuro nel repository GitHub utilizzando i segreti e le variabili di GitHub. Questo aggiunge un livello di sicurezza e comodità extra al processo di distribuzione di PySpark.

Segui questi passaggi per impostare i tuoi valori AWS:

Accedi al tuo repository GitHub

• Puoi semplicemente navigare nel tuo repository GitHub, dove ospiti il tuo progetto PySpark.

Accedi alle impostazioni del repository

• All’interno del tuo repository, fai clic sulla scheda “Impostazioni”.

Gestione dei segreti

• Nella barra laterale sinistra, troverai un’opzione chiamata “Segreti”. Clicca su di essa per accedere all’interfaccia di gestione dei segreti di GitHub.

Aggiungi un nuovo segreto

• Qui puoi aggiungere i tuoi valori di configurazione AWS come segreti.
• Fai clic su “Nuovo segreto del repository” per creare un nuovo segreto.
• Per ogni valore AWS, crea un segreto con un nome che corrisponde allo scopo del valore (ad esempio, “AWS_ACCESS_KEY_ID”, “AWS_SECRET_ACCESS_KEY”, “AWS_REGION”, ecc.).
• Inserisci il valore effettivo nel campo “Valore”.

Salva i tuoi segreti

• Fai clic sul pulsante “Aggiungi segreto” per ogni valore per salvarlo come segreto di GitHub.

Con i tuoi segreti AWS memorizzati in modo sicuro su GitHub, puoi facilmente farvi riferimento nei flussi di lavoro di GitHub Actions e accedere in modo sicuro ai servizi AWS durante la distribuzione.

Best Practice

• I segreti di GitHub sono crittografati e possono essere accessibili solo dagli utenti autorizzati con le necessarie autorizzazioni. Questo garantisce la sicurezza dei tuoi valori sensibili AWS.
• Utilizzando i segreti di GitHub, eviti di esporre informazioni sensibili direttamente nel tuo codice o nei file di configurazione, migliorando la sicurezza del tuo progetto.

I tuoi valori di configurazione AWS sono ora correttamente configurati nel tuo repository GitHub, rendendoli prontamente disponibili per il tuo flusso di lavoro di distribuzione di PySpark.

Comprendere la struttura del codice

Per distribuire in modo efficace PySpark su AWS utilizzando Docker, è essenziale comprendere la struttura del codice del tuo progetto. Analizziamo i componenti che costituiscono la base del codice:

├── .github│   ├── workflows│   │   ├── build.yml├── airflow├── configs├── consumerComplaint│   ├── cloud_storage│   ├── components│   ├── config│   │   ├── py_sparkmanager.py│   ├── constants│   ├── data_access│   ├── entity│   ├── exceptions│   ├── logger│   ├── ml│   ├── pipeline│   ├── utils├── output│   ├── .png├── prediction_data├── research│   ├── jupyter_notebooks├── saved_models│   ├── model.pkl├── tests├── venv├── Dockerfile├── app.py├── requirements.txt├── .gitignore├── .dockerignore

Codice dell’applicazione (app.py)

• app.py è lo script principale in Python che si occupa dell’esecuzione dell’applicazione PySpark.
• È il punto di ingresso per i tuoi lavori PySpark e serve come nucleo dell’applicazione.
• Puoi personalizzare questo script per definire le pipeline di elaborazione dei dati, la pianificazione dei lavori e altro ancora.

Dockerfile

• Il Dockerfile contiene le istruzioni per la creazione di un’immagine Docker per la tua applicazione PySpark.
• Specifica l’immagine di base, aggiunge le dipendenze necessarie, copia il codice dell’applicazione nel contenitore e configura l’ambiente di esecuzione.
• Questo file svolge un ruolo fondamentale nell’incapsulamento dell’applicazione per una distribuzione senza problemi.

Requisiti (requirements.txt)

• requirements.txt elenca i pacchetti Python e le dipendenze necessari per la tua applicazione PySpark.
• Questi pacchetti vengono installati all’interno del contenitore Docker per garantire un’esecuzione senza problemi dell’applicazione.

Flussi di lavoro di GitHub Actions

• I flussi di lavoro di GitHub Actions sono definiti in .github/workflows/ all’interno del repository del tuo progetto.
• Automatizzano i processi di build, testing e distribuzione.
• I file di flusso di lavoro, come main.yml, descrivono i passi da eseguire quando si verificano eventi specifici, come push di codice o pull requests.

Build py_sparkmanager.py

import osfrom dotenv import load_dotenvfrom pyspark.sql import SparkSession# Carica le variabili di ambiente da .envload_dotenv()access_key_id = os.getenv("AWS_ACCESS_KEY_ID")secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")# Inizializza SparkSessionspark_session = SparkSession.builder.master('local[*]').appName('consumer_complaint') \    .config("spark.executor.instances", "1") \    .config("spark.executor.memory", "6g") \    .config("spark.driver.memory", "6g") \    .config("spark.executor.memoryOverhead", "8g") \    .config('spark.jars.packages', "com.amazonaws:aws-java-sdk:1.7.4,  org.apache.hadoop:hadoop-aws:2.7.3") \    .getOrCreate()# Configura SparkSession per l'accesso a AWS S3spark_session._jsc.hadoopConfiguration().set("fs.s3a.awsAccessKeyId", access_key_id)spark_session._jsc.hadoopConfiguration().set("fs.s3a.awsSecretAccessKey", secret_access_key)spark_session._jsc.hadoopConfiguration().set("fs.s3a.impl",               "org.apache.hadoop.fs.s3a.S3AFileSystem")spark_session._jsc.hadoopConfiguration().set("com.amazonaws.services.s3.enableV4", "true")spark_session._jsc.hadoopConfiguration().set("fs.s3a.aws.credentials.provider",              "org.apache.hadoop.fs.s3a.BasicAWSCredentialsProvider")spark_session._jsc.hadoopConfiguration().set("fs.s3a.endpoint", "ap-south-1.amazonaws.com")spark_session._jsc.hadoopConfiguration().set("fs.s3.buffer.dir", "tmp")

Questo codice configura la tua SparkSession, la configura per l’accesso a AWS S3 e carica le credenziali AWS dalle variabili di ambiente, consentendoti di lavorare in modo trasparente con i servizi AWS nella tua applicazione PySpark.

Preparazione delle immagini Docker di PySpark (IMP)

Questa sezione esplorerà come creare immagini Docker che racchiudono la tua applicazione PySpark, rendendola portatile, scalabile e pronta per essere distribuita su AWS. I container Docker forniscono un ambiente coerente per le tue applicazioni PySpark, garantendo l’esecuzione senza soluzione di continuità in diversi contesti.

Dockerfile

La chiave per la creazione di immagini Docker per PySpark è un Dockerfile ben definito. Questo file specifica le istruzioni per la configurazione dell’ambiente del contenitore, inclusa la dipendenza da Python e PySpark.

FROM python:3.8.5-slim-buster# Usa un'immagine di base di UbuntuFROM ubuntu:20.04# Imposta JAVA_HOME e installa OpenJDK 8ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/RUN apt-get update -y \    && apt-get install -y openjdk-8-jdk \    && apt-get install python3-pip -y \    && apt-get clean \    && rm -rf /var/lib/apt/lists/*# Imposta le variabili d'ambiente per la tua applicazioneENV AIRFLOW_HOME="/app/airflow"ENV PYSPARK_PYTHON=/usr/bin/python3ENV PYSPARK_DRIVER_PYTHON=/usr/bin/python3# Crea una directory per la tua applicazione e impostala come directory di lavoroWORKDIR /app# Copia i contenuti della directory corrente nella directory di lavoro nel contenitoreCOPY . /app# Installa le dipendenze Python da requirements.txtRUN pip3 install -r requirements.txt# Imposta il punto di ingresso per eseguire lo script app.pyCMD ["python3", "app.py"]

Creazione dell’immagine Docker

Dopo aver preparato il tuo Dockerfile, puoi creare l’immagine Docker utilizzando il seguente comando:

docker build -t nome-immagine-tua

Sostituisci nome-immagine-tua con il nome desiderato e la versione per la tua immagine Docker.

Verifica dell’immagine locale

Dopo aver creato l’immagine, puoi elencare le immagini Docker locali utilizzando il seguente comando:

docker imagesdocker ps -a docker system df

Esecuzione di PySpark in Docker

Con la tua immagine Docker preparata, puoi procedere ed eseguire la tua applicazione PySpark in un contenitore Docker. Usa il seguente comando:

docker run -nome-immagine-tua

““” A VOLTE IL COMANDO docker run NON FUNZIONA, SEGUI IL COMANDO SEGUENTE. “““

docker run 80:8080 nome-immagine-tuadocker run 8080:8080 nome-immagine-tua

Deploy di PySpark su AWS

In questa sezione verrà illustrato come distribuire la tua applicazione PySpark su AWS utilizzando i container Docker. Questa distribuzione prevede il lancio di istanze Amazon Elastic Compute Cloud (EC2) per creare un cluster PySpark.

Lancia le istanze EC2

• Nella Dashboard EC2, fai clic su “Launch Instances”.
• Puoi selezionare un’Amazon Machine Image (AMI) che soddisfi le tue esigenze, di solito basato su Linux.
• In base al tuo carico di lavoro, scegli il tipo di istanza (ad esempio, m5.large, c5.xlarge).
• Configura i dettagli dell’istanza, inclusi il numero di istanze nel tuo cluster.
• Aggiungi archiviazione, tag e gruppi di sicurezza se necessario.

Tutto ciò che ho menzionato è qui.

Connetti alle istanze EC2

• Una volta che le istanze sono in esecuzione, puoi accedere tramite SSH per gestire il tuo cluster PySpark.

Scrivi il seguente comando

Scarica lo script di installazione di Docker

curl -fsSL https://get.docker.com -o get-docker.sh

Esegui lo script di installazione di Docker con privilegi di root

sudo sh get-docker.sh

Aggiungi l’utente corrente al gruppo di docker (sostituisci ‘ubuntu’ con il tuo nome utente)

sudo usermod -aG docker ubuntu

Attiva le modifiche eseguendo una nuova sessione della shell o utilizzando ‘newgrp’

newgrp docker

Costruzione di un GitHub Self-Hosted Runner

Imposteremo un runner self-hosted per le azioni di GitHub, responsabile dell’esecuzione dei tuoi flussi di lavoro CI/CD. Un runner self-hosted viene eseguito sulla tua infrastruttura ed è una buona scelta per l’esecuzione di flussi di lavoro che richiedono configurazioni specifiche o accesso alle risorse locali.

Configurazione del Runner Self-Hosted

• Clicca su impostazioni
• Clicca su Azioni -> Runner

• Clicca su Nuovo runner self-hosted

Scrivi il comando sottostante sulla macchina EC2

• Crea una cartella: Questo comando crea una directory chiamata actions-runner e cambia la directory corrente in questa nuova cartella.

$ mkdir actions-runner && cd actions-runner

• Scarica il pacchetto runner più recente: Questo comando scarica il pacchetto runner di GitHub Actions per Linux x64. Specifica l’URL del pacchetto da scaricare e lo salva con il nome del file actions-runner-linux-x64-2.309.0.tar.gz.

$ curl -o actions-runner-linux-x64-2.309.0.tar.gz -L https://github.com/actions/runner/releases/download/v2.309.0/actions-runner-linux-x64-2.309.0.tar.gz

• Facoltativo: Verifica l’hash: Questo comando verifica l’integrità del pacchetto scaricato convalidando il suo hash. Calcola l’hash SHA-256 del pacchetto scaricato e lo confronta con un hash noto e previsto. Se corrispondono, il pacchetto viene considerato valido.

$ echo "2974243bab2a282349ac833475d241d5273605d3628f0685bd07fb5530f9bb1a  actions-runner-linux-x64-2.309.0.tar.gz" | shasum -a 256 -c

• Estrai l’installatore: Questo comando estrae i contenuti del pacchetto scaricato, che è un archivio compresso.

$ tar xzf ./actions-runner-linux-x64-2.309.0.tar.gz

• Ultimo passaggio, eseguilo: Questo comando avvia il runner con le impostazioni di configurazione fornite. Configura il runner per eseguire flussi di lavoro di GitHub Actions per il repository specificato.

$ ./run.sh

Configurazione del flusso di lavoro di Continuous Integration and Continuous Delivery (CICD)

In un pipeline CI/CD, il file build.yaml è cruciale per definire i passaggi necessari per compilare e distribuire la tua applicazione. Questo file di configurazione specifica il flusso di lavoro per il tuo processo CI/CD, compresa la compilazione del codice, i test e il rilascio. Approfondiamo gli aspetti critici della configurazione build.yaml e la sua importanza:

Panoramica del flusso di lavoro

Il file build.yaml esemplifica le attività eseguite durante la pipeline CI/CD. Definisce i passaggi per l’integrazione continua, che comprende la compilazione e i test dell’applicazione, e la consegna continua, in cui l’applicazione viene distribuita su diversi ambienti.

Integrazione continua (CI)

In questa fase sono incluse tipicamente attività come la compilazione del codice, il testing unitario e il controllo della qualità del codice. Il file build.yaml specifica gli strumenti, gli script e i comandi necessari per eseguire queste attività. Ad esempio, potrebbe attivare l’esecuzione dei test unitari per garantire la qualità del codice.

Consegna continua (CD)

Dopo un’Integrazione continua di successo, la fase di CD prevede la distribuzione dell’applicazione su ambienti diversi, come staging o produzione. Il file build.yaml specifica come deve avvenire il rilascio, incluso dove e quando distribuire e quali configurazioni utilizzare.

Gestione delle dipendenze

Il file build.yaml spesso include i dettagli sulle dipendenze del progetto. Definisce da dove recuperare librerie esterne o dipendenze, che possono essere cruciali per la riuscita della compilazione e del deployment dell’applicazione.

Variabili di ambiente

I flussi di lavoro CI/CD spesso richiedono configurazioni specifiche dell’ambiente, come chiavi API o stringhe di connessione. Il file build.yaml può definire come vengono impostate queste variabili di ambiente per ogni fase del processo.

Notifiche e avvisi

In caso di errori o problemi durante il processo CI/CD, le notifiche e gli avvisi sono essenziali. Il file build.yaml può configurare come e a chi vengono inviati questi avvisi, garantendo che i problemi vengano affrontati tempestivamente.

Artefatti e output

A seconda del flusso di lavoro CI/CD, il file build.yaml può specificare quali artefatti o output di compilazione devono essere generati e dove devono essere archiviati. Questi artefatti possono essere utilizzati per il deployment o per ulteriori test.

Comprendendo il file build.yaml e i suoi componenti, è possibile gestire ed personalizzare in modo efficace il flusso di lavoro CI/CD per soddisfare le esigenze del progetto. È la base per l’intero processo di automazione, dai cambiamenti del codice ai deployment in produzione.

Pipeline CI/CD

È possibile personalizzare ulteriormente il contenuto in base ai dettagli specifici della configurazione del file build.yaml e a come si adatta alla pipeline CI/CD.

name: workflowon:  push:    branches:      - main    paths-ignore:      - 'README.md'permissions:  id-token: write  contents: readjobs:  integration:    name: Continuous Integration    runs-on: ubuntu-latest    steps:      - name: Checkout Code        uses: actions/checkout@v3      - name: Lint code        run: echo "Verifica del codice"      - name: Esegui i test unitari        run: echo "Esecuzione dei test unitari"  build-and-push-ecr-image:    name: Continuous Delivery    needs: integration    runs-on: ubuntu-latest    steps:      - name: Checkout Code        uses: actions/checkout@v3      - name: Installa Utilità        run: |          sudo apt-get update          sudo apt-get install -y jq unzip      - name: Configura le credenziali AWS        uses: aws-actions/configure-aws-credentials@v1        with:          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}          aws-region: ${{ secrets.AWS_REGION }}      - name: Accedi ad Amazon ECR        id: login-ecr        uses: aws-actions/amazon-ecr-login@v1      - name: Compila, etichetta e invia l'immagine a Amazon ECR        id: build-image        env:          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}          ECR_REPOSITORY: ${{ secrets.ECR_REPOSITORY_NAME }}          IMAGE_TAG: latest        run: |          # Compila un container Docker e          # lo invia a ECR in modo che possa          # essere distribuito su ECS.          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG          echo "::set-output name=image::$ECR_REGISTRY/$ECR_REPOSITORY            :$IMAGE_TAG"                      Continuous-Deployment:    needs: build-and-push-ecr-image    runs-on: self-hosted    steps:      - name: Checkout        uses: actions/checkout@v3      - name: Configura le credenziali AWS        uses: aws-actions/configure-aws-credentials@v1        with:          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}          aws-region: ${{ secrets.AWS_REGION }}      - name: Accedi ad Amazon ECR        id: login-ecr        uses: aws-actions/amazon-ecr-login@v1                  - name: Scarica le immagini più recenti        run: |         docker pull ${{secrets.AWS_ECR_LOGIN_URI}}/${{ secrets.         ECR_REPOSITORY_NAME }}:latest      - name: Arresta e rimuovi il container del sensore se in esecuzione        run: |         docker ps -q --filter "name=sensor" | grep -q . && docker stop sensor         && docker rm -fv sensor             - name: Esegui l'immagine Docker per servire gli utenti        run: |         docker run -d -p 80:8080 --name=sensor -e 'AWS_ACCESS_KEY_ID=                  ${{ secrets.AWS_ACCESS_KEY_ID }}       ' -e 'AWS_SECRET_ACCESS_KEY=${{ secrets.AWS_SECRET_ACCESS_KEY }}'       -e 'AWS_REGION=${{ secrets.AWS_REGION }}'  ${{secrets.AWS_ECR_LOGIN_URI}}/      ${{ secrets.ECR_REPOSITORY_NAME }}:latest      - name: Pulisci le immagini e i container precedenti        run: |         docker system prune -f

Nota: Tutte le linee spezzate si uniscono come unaSe si verifica qualche problema, seguire il repository GitHub che ho menzionato in precedenza.

Lavoro di Continuous-Deployment:

• Questo lavoro dipende dal “Build-and-Push-ECR-Image Job” ed è configurato per essere eseguito su un runner self-hosted.
• Controlla il codice e configura le credenziali AWS.
• Accede ad Amazon ECR.
• Recupera l’ultima immagine Docker dal repository ECR specificato.
• Interrompe e rimuove un container Docker chiamato “sensor” se è in esecuzione.
• Esegue un container Docker chiamato “sensor” con le impostazioni, le variabili d’ambiente e l’immagine Docker recuperata in precedenza.
• Infine, pulisce le immagini e i container Docker precedenti usando docker system prune.

Automatizzare l’esecuzione del flusso di lavoro in caso di modifiche del codice

Per rendere l’intero processo CI/CD senza soluzione di continuità e reattivo alle modifiche del codice, è possibile configurare il repository per avviare automaticamente il flusso di lavoro al verificarsi di commit o push del codice. Ogni volta che si salvano e si effettuano push delle modifiche al repository, la pipeline CI/CD inizia a fare la sua magia.

Automatizzando l’esecuzione del flusso di lavoro, si garantisce che l’applicazione sia sempre aggiornata con le ultime modifiche senza intervento manuale. Questa automazione può migliorare significativamente l’efficienza dello sviluppo e fornire un feedback rapido sulle modifiche al codice, facilitando la rilevazione e la risoluzione tempestiva dei problemi fin dalle prime fasi del ciclo di sviluppo.

Per configurare l’esecuzione automatica del flusso di lavoro in caso di modifiche del codice, seguire questi passaggi:

git add .git commit -m "messaggio"git push origin main

Conclusioni

In questa guida completa, ti abbiamo guidato attraverso il processo complesso di distribuzione di PySpark su AWS utilizzando EC2 ed ECR. Utilizzando la containerizzazione e l’integrazione continua e il rilascio, questa approccio fornisce una soluzione robusta e adattabile per la gestione di attività di analisi e elaborazione di dati su larga scala. Seguendo i passaggi descritti in questo articolo, puoi sfruttare pienamente il potenziale di PySpark in un ambiente cloud, sfruttando la scalabilità e la flessibilità offerte da AWS.

È importante notare che AWS offre molte opzioni di distribuzione, da EC2 ed ECR a servizi specializzati come EMR. La scelta del metodo dipende delle esigenze uniche del tuo progetto. Che tu preferisca l’approccio della containerizzazione dimostrato qui o opti per un diverso servizio AWS, l’importante è sfruttare efficacemente le capacità di PySpark nelle tue applicazioni data-driven. Con AWS come piattaforma, sei ben attrezzato per sbloccare tutto il potenziale di PySpark, aprendo una nuova era di analisi e elaborazione dei dati. Esplora servizi come EMR se si adattano meglio ai tuoi casi d’uso specifici e alle tue preferenze, poiché AWS offre un toolkit diversificato per distribuire PySpark per soddisfare le esigenze uniche dei tuoi progetti.

Punti chiave

• La distribuzione di PySpark su AWS con Docker semplifica l’elaborazione di big data, offrendo scalabilità e automazione.
• Le azioni di GitHub semplificano la pipeline CI/CD, consentendo un rilascio del codice senza soluzione di continuità.
• Sfruttare i servizi AWS come EC2 ed ECR garantisce una robusta gestione del cluster PySpark.
• Questo tutorial ti prepara per sfruttare il potere del computing cloud per attività di elaborazione intensiva di dati.

Domande frequenti

Risorse per ulteriori approfondimenti

• Repository GitHub: Accedi al codice sorgente completo e alle configurazioni utilizzate in questo tutorial sul repository GitHub per Consumer Complaint Dispute Prediction.
• Documentazione Docker: Approfondisci Docker e la containerizzazione esplorando la documentazione ufficiale di Docker. Troverai guide complete, best practice e consigli per padroneggiare Docker.
• Documentazione GitHub Actions: Sfrutta al massimo le GitHub Actions consultando la documentazione di GitHub Actions. Questa risorsa ti aiuterà a creare, personalizzare ed automatizzare i tuoi flussi di lavoro.
• Documentazione ufficiale di PySpark: Per conoscere approfonditamente PySpark, puoi esplorare la documentazione ufficiale di PySpark. Scopri le API, le funzioni e le librerie per l’elaborazione di big data.

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell’autore.