Preparazione dell'ambiente di elaborazione batch sull'ecosistema Hadoop

Per configurare l'elaborazione batch sull'ecosistema Hadoop, è necessario preparare l'ambiente di distribuzione.

Prerequisiti

Per configurare l'elaborazione batch sull'ecosistema Hadoop è necessario disporre dei seguenti artefatti:

  • Una versione di Apache Hive 2.3.7 o un database successivo
  • Apache Hadoop 2.10.0 con Apache Spark 2.4.7
  • Un motore Docker per creare e impacchettare l'applicazione Spark Manager
  • Un notebook specializzato che si utilizza insieme per le valutazioni dei modelli
  • Una tabella di feedback, una tabella di dati di formazione e una tabella di registrazione del carico utile create nel database Hive
  • Livy e WebHDFS sono disponibili sull'ecosistema Hadoop, richiede Apache Hadoop 2.10.0
  • Un insieme di utenti che possono accedere a questa applicazione tramite autenticazione di base
  • Un archivio dell' Python che contiene i moduli necessari per la valutazione del modello
  • Una drifted_transaction tabella che memorizza le transazioni utilizzate per l'analisi post-elaborazione
  • Facoltativamente, un ecosistema Kerberizzato Hadoop per l'esecuzione dell'applicazione

Passaggio 1: assicurarsi che Livy e WebHDFS siano disponibili sull'ecosistema Hadoop

Poiché l'applicazione Spark Manager utilizza Livy per inviare lavori e WebHDFS per accedere ai file, è necessario installare Livy e WebHDFS per accedere all'ecosistema Hadoop. Se Livy e WebHDFS non sono installati, è necessario richiederli. L'amministratore del cluster Hadoop può fornire gli URL di base per Livy, WebHDFS, e la base di file HDFS. È necessario disporre di questi URL per preparare l'ambiente di distribuzione. Gli esempi seguenti mostrano gli URL di base per Livy, WebHDFS, e la base file HDFS :

  • WebHDFS URL: http://$hostname:50070

  • HDFS file base URL : hdfs://$hostname:9000

  • Livy URL: http://$hostname:8998

È inoltre possibile richiedere i seguenti elementi all'amministratore del cluster Hadoop :

  • Un percorso di base nel file system dell' HDFS e in cui è possibile scrivere file
  • Percorso del file yarn.keytab, specificato come parametro conf.spark.yarn.keytab nel payload della richiesta di lavoro

Passaggio 2: utilizzo di un ecosistema Kerberizzato Hadoop

Se si esegue l'applicazione in un ecosistema Kerberizzato Hadoop, l'applicazione deve generare un ticket Kerberos prima di poter inviare richieste a Livy o WebHDFS. Per generare un ticket Kerberos, sono necessari i seguenti file e ID:

  • Un file keytab

  • Un file krb5.conf

  • Un utente Kerberos principale

Per l'autenticazione al Key Distribution Center (KDC), i computer abilitati all Kerberos richiedono un file keytab. Il file keytab è una copia crittografata e locale su disco della chiave host. L'amministratore del cluster Hadoop deve fornire questo file keytab. È necessario richiedere il hdfs.keytab file per preparare l'ambiente di distribuzione.

Il krb5. conf file contiene informazioni di configurazione dell' Kerberos, quali le posizioni dei KDC e dei server di amministrazione per i domini dell' Kerberos. Il file contiene anche le impostazioni predefinite per il dominio corrente e per le applicazioni Kerberos, nonché le mappature dei nomi host sui domini Kerberos. L'amministratore del cluster Hadoop deve fornire questo file di configurazione. È necessario richiedere il krb5.conf file per preparare l'ambiente di distribuzione.

Un'entità principale (principal) di Kerberos rappresenta un'identità univoca, ad esempio openscale_user1/$hostname@HADOOPCLUSTER.LOCAL in un sistema Kerberos in cui Kerberos può assegnare ticket per accedere a servizi compatibili con Kerberos. I nomi principali contengono diversi componenti separati da una barra ( / ). È anche possibile specificare un dominio come ultimo componente del nome utilizzando il simbolo @. L'amministratore del cluster Hadoop deve fornire l'ID principale. È necessario richiedere l'ID principale per preparare l'ambiente di distribuzione. Se hai bisogno che più utenti possano inviare lavori, devi richiedere più ID principali.

Passaggio 3: creare un elenco di utenti autorizzati ad accedere a questa applicazione tramite autenticazione di base

È necessario creare un elenco di nomi utente e password autorizzati ad accedere all'applicazione Spark Manager tramite autenticazione di base. Questo elenco di nomi utente e password autorizzati deve essere specificato in un auth.json file.

Passaggio 4: Creare un archivio Python dei moduli necessari per la valutazione del modello

Le valutazioni dei modelli eseguite sull'ecosistema Hadoop richiedono pacchetti Python dipendenti. Senza questi pacchetti, le valutazioni falliscono. È possibile seguire i passaggi riportati di seguito per installare queste dipendenze e caricarle in una posizione nel sistema di file distribuito di Hadoop ( HDFS ).

  1. Accedere a un sistema operativo Linux su cui è installato Python e verificare la versione di Python eseguendo il seguente comando:

    python --version
Python 3.7.9

  2. Installa il python3-devel pacchetto, che installa le librerie GNU Compiler Collection (GCC), eseguendo il seguente comando:

    yum install python3-devel

  3. Passare alla directory in cui è stato creato l'ambiente virtuale Python, ad esempio la /opt cartella:

    cd /opt

  4. Elimina qualsiasi ambiente virtuale creato in precedenza eseguendo il seguente comando.

    rm -fr wos_env
rm -fr wos_env.zip

    La wos_env cartella contiene un ambiente virtuale Python con dipendenze Spark Job al suo interno.

  5. Crea e attiva l'ambiente virtuale eseguendo i seguenti comandi.

    python -m venv wos_env
source wos_env/bin/activate

    L'ambiente wos_env virtuale viene creato e il source comando attiva l'ambiente virtuale.

  6. Aggiorna l'ambiente pip eseguendo il seguente comando:

    pip install --upgrade pip

  7. Per installare tutte le dipendenze, scegli se installarle singolarmente o con un processo batch in un file. Devono essere installati nel seguente ordine.

    • Se utilizzi Python 3.7, esegui i seguenti comandi per installare singolarmente i file richiesti:

      python -m pip install numpy==1.20.2
python -m pip install scipy==1.6.3
python -m pip install pandas==1.2.4
python -m pip install scikit-learn==0.24.2
python -m pip install osqp==0.6.1
python -m pip install cvxpy==1.0.25
python -m pip install marshmallow==3.11.1
python -m pip install requests==2.25.1
python -m pip install jenkspy==0.2.0
python -m pip install pyparsing==2.4.7
python -m pip install tqdm==4.60.0
python -m pip install more_itertools==8.7.0
python -m pip install tabulate==0.8.9
python -m pip install py4j==0.10.9.2
python -m pip install pyarrow==4.0.0
python -m pip install "ibm-wos-utils==4.6.*"

    È possibile inserire tutti i moduli in un requirements.txt file ed eseguire i comandi contemporaneamente.

    • Se utilizzi Python 3.7, crea il requirements.txt file aggiungendo le seguenti righe al file. Quindi, esegui il python -m pip install -r requirements.txt comando:

      numpy==1.20.2
scipy==1.6.3
pandas==1.2.4
osqp==0.6.1
cvxpy==1.0.25
marshmallow==3.11.1
requests==2.25.1
jenkspy==0.2.0
pyparsing==2.4.7
tqdm==4.60.0
more_itertools==8.7.0
tabulate==0.8.9
py4j==0.10.9.2
pyarrow==4.0.0
ibm-wos-utils==4.6.*

  8. Disattiva l'ambiente virtuale eseguendo il deactivate comando.

Passaggio 5: Caricare l'archivio

È necessario comprimere l'ambiente virtuale e caricare il file di archivio su HDFS.

  1. Crea un file compresso contenente l'ambiente virtuale eseguendo i seguenti comandi:

    zip -r wos_env.zip wos_env/
ls -alt --block-size=M wos_env.zip

  2. Esegui l'autenticazione su HDFS eseguendo il seguente comando:

    kinit -kt /home/hadoop/keytabs/hdfs.keytab hdfs/$HOST@#REALM

  3. In HDFS, crea una py_packages cartella e aggiungi il wos_env.zip file a tale cartella eseguendo i seguenti comandi:

    hdfs dfs -mkdir /py_packages
hdfs dfs -put -f wos_env.zip /py_packages

  4. Verifica di aver aggiunto correttamente il file a HDFS eseguendo il seguente comando:

    hdfs dfs -ls /py_packages

    Quando il file viene aggiunto correttamente, viene visualizzato il seguente output:

    Found 1 items
-rw-r--r--   2 hdfs supergroup  303438930 2020-10-07 16:23 /py_packages/wos_env.zip

Passaggio 6: impacchettare l'applicazione in un'immagine Docker

È necessario impacchettare l'applicazione in un'immagine Docker e clonare il repository GitHub che contiene l'applicazione di riferimento Spark Manager per i processi batch.

  1. Clona il repository GitHub nella cartella wos-spark-manager-api.

  2. Passa alla cartella wos-spark-manager-api.

  3. Aggiorna il service/security/auth.json file con gli utenti dell'elenco di autorizzazione che hai creato. Il file aggiornato è simile al seguente modello:

    {
  "allowlisted_users": {
    "openscale_user1": "passw0rd",
    "openscale_user2": "passw0rd",
    "openscale_user3": "passw0rd",
    "openscale": "passw0rd"
  }
}

  4. Se si sta preparando questa applicazione per l'esecuzione su un cluster Kerberizzato Hadoop, è necessario completare anche i seguenti passaggi:

    1. Posiziona il file hdfs.keytab e il krb5.conf file nella directory principale della wos-spark-manager-api cartella

    2. Aggiorna il service/security/auth.json file con la user_kerberos_mapping mappatura che contiene i principali Kerberos forniti dall'amministratore. Il file è simile al seguente modello:

      {
  "allowlisted_users": {
    "openscale_user1": "passw0rd",
    "openscale_user2": "passw0rd",
    "openscale_user3": "passw0rd",
    "openscale": "passw0rd"
  },
  "user_kerberos_mapping" : {
    "openscale_user1": "openscale_user1/$hostname@HADOOPCLUSTER.LOCAL",
    "openscale_user2": "openscale_user2/$hostname@HADOOPCLUSTER.LOCAL",
    "openscale_user3": "openscale_user3/$hostname@HADOOPCLUSTER.LOCAL"
  }
}

    3. Nel payload/Dockerfile file, rimuovere il commento dalle righe 53-55.

  5. Esegui il seguente comando per creare l'immagine docker:

    docker build -t <repository/image_name>:version> -f payload/Dockerfile .

  6. Se utilizzi una nuova macchina virtuale ( VM ) per creare il pacchetto della tua applicazione, segui questi passaggi per trasferire l'immagine Docker sul tuo nuovo VM :

    1. Salva l'immagine docker come tarball eseguendo il seguente comando:

      docker save myimage:latest | gzip > myimage_latest.tar.gz

    2. Archivia il file tarball sull'altro server remoto VM.

    3. Carica il tarball eseguendo il seguente comando:

      docker load < myimage_latest.tar.gz

Passaggio 7: Eseguire l'applicazione

  1. Accedi alla macchina virtuale ( VM ) su cui intendi eseguire l'applicazione. Verificare che l' VM e abbia installato Docker.

    Se l'indirizzo VM è diverso da quello in cui è stata creata l'immagine Docker, è necessario salvare e caricare l'immagine Docker su questo indirizzo VM.

  2. Componi il file di ambiente utilizzato per avviare Docker. È necessario disporre di tutti i valori richiesti per comporre il docker.env file.

    1. Crea un docker.env file.

    2. Aggiungi le seguenti voci nel docker.env file:

      WEB_HDFS_URL=http://lamy1.fyre.companyserver.com:50070
HDFS_FILE_BASE_URL=hdfs://lamy1.fyre.companyserver.com:9000
SPARK_LIVY_URL=http://sheaffer1.fyre.companyserver.com:8998
BASE_HDFS_LOCATION=sw/openscale
WOS_ENV_ARCHIVE_LOCATION=hdfs://lamy1.fyre.companyserver.com:9000/py_packages/wos_env.zip#wos_env
WOS_ENV_SITE_PACKAGES_PATH=./wos_env/wos_env/lib/python3.6/site-packages:

    3. Se l'applicazione viene eseguita su un cluster Kerberizzato Hadoop, aggiungere le seguenti voci aggiuntive al docker.env file

      KERBEROS_ENABLED=true
HDFS_KEYTAB_FILE_PATH=/opt/ibm/wos/python/keytabs/hdfs.keytab
SPARK_YARN_KEYTAB_FILE_PATH=/home/hadoop/hadoop/etc/hadoop/yarn.keytab

  3. Elenca le immagini Docker e ottieni il $IMAGE_ID valore eseguendo il seguente comando:

    docker images

  4. Avvia il container Docker eseguendo il seguente comando:

    docker run --env-file docker.env -p 5000:9443 --name wos-spark-manager-api $IMAGE_ID

Ora è possibile accedere alle API con il seguente URL : http://<VM-HOST-NAME>:5000. Ora è anche possibile visualizzare la documentazione Swagger al seguente indirizzo: http://<VM-HOST-NAME>:5000/spark_wrapper/api/explorer URL.

Passi successivi

Configurare l'elaborazione batch nell' Watson OpenScale