Eseguire la migrazione dall'archivio HDFS locale a Archiviazione di Azure con Azure Data Box

Articolo
10/18/2023

È possibile eseguire la migrazione dei dati da un archivio HDFS locale del cluster Hadoop in Archiviazione di Azure (archiviazione BLOB o Data Lake Archiviazione Gen2) usando un dispositivo Data Box. È possibile scegliere tra Data Box Disk, Data Box Da 80 TB o Data Box Heavy da 770 TB.

Questo articolo consente di completare queste attività:

Preparare la migrazione dei dati
Copiare i dati in un dispositivo Data Box Disk, Data Box o Data Box Heavy
Rispenire il dispositivo a Microsoft
Applicare autorizzazioni di accesso a file e directory (solo Data Lake Archiviazione Gen2)

Prerequisiti

Questi elementi sono necessari per completare la migrazione.

Un account di archiviazione di Azure.
Un cluster Hadoop locale che contiene i dati di origine.
Un dispositivo Azure Data Box.
- Ordinare Data Box o Data Box Heavy.
- Cablare e connettere Data Box o Data Box Heavy a una rete locale.

Se sei pronto, iniziamo.

Copiare i dati in un dispositivo Data Box

Se i dati si adattano a un singolo dispositivo Data Box, copiare i dati nel dispositivo Data Box.

Se le dimensioni dei dati superano la capacità del dispositivo Data Box, usare la procedura facoltativa per suddividere i dati in più dispositivi Data Box e quindi eseguire questo passaggio.

Per copiare i dati dall'archivio HDFS locale in un dispositivo Data Box, è necessario impostare alcune operazioni e quindi usare lo strumento DistCp .

Seguire questa procedura per copiare i dati tramite le API REST dell'archiviazione BLOB/oggetti nel dispositivo Data Box. L'interfaccia DELL'API REST rende il dispositivo visualizzato come archivio HDFS nel cluster.

Prima di copiare i dati tramite REST, identificare le primitive di sicurezza e connessione per connettersi all'interfaccia REST in Data Box o Data Box Heavy. Accedere all'interfaccia utente Web locale di Data Box e passare a Connessione e copiare la pagina. Negli account di archiviazione di Azure per il dispositivo, in Impostazioni di accesso individuare e selezionare REST.
Nella finestra di dialogo Accedere all'account di archiviazione e caricare i dati copiare l'endpoint del servizio BLOB e la chiave dell'account Archiviazione. Dall'endpoint del servizio BLOB omettere https:// e la barra finale.

In questo caso, l'endpoint è: https://mystorageaccount.blob.mydataboxno.microsoftdatabox.com/. La parte host dell'URI usata è: mystorageaccount.blob.mydataboxno.microsoftdatabox.com. Per un esempio, vedere come Connessione a REST su http.
Aggiungere l'endpoint e l'indirizzo IP del nodo Data Box o Data Box Heavy a /etc/hosts in ogni nodo.
```
10.128.5.42  mystorageaccount.blob.mydataboxno.microsoftdatabox.com
```
Se si usa un altro meccanismo per DNS, è necessario assicurarsi che l'endpoint Data Box possa essere risolto.
Impostare la variabile shell sul percorso dei hadoop-azure file con estensione azjars jar e azure-storage . È possibile trovare questi file nella directory di installazione di Hadoop.

Per determinare se questi file esistono, usare il comando seguente: ls -l $<hadoop_install_dir>/share/hadoop/tools/lib/ | grep azure. Sostituire il <hadoop_install_dir> segnaposto con il percorso della directory in cui è stato installato Hadoop. Assicurarsi di usare percorsi completi.

Esempi:

azjars=$hadoop_install_dir/share/hadoop/tools/lib/hadoop-azure-2.6.0-cdh5.14.0.jar azjars=$azjars,$hadoop_install_dir/share/hadoop/tools/lib/microsoft-windowsazure-storage-sdk-0.6.0.jar
Creare il contenitore di archiviazione da usare per la copia dei dati. È anche necessario specificare una directory di destinazione come parte di questo comando. Potrebbe trattarsi di una directory di destinazione fittizia a questo punto.
```
hadoop fs -libjars $azjars \
-D fs.AbstractFileSystem.wasb.Impl=org.apache.hadoop.fs.azure.Wasb \
-D fs.azure.account.key.<blob_service_endpoint>=<account_key> \
-mkdir -p  wasb://<container_name>@<blob_service_endpoint>/<destination_directory>
```
- Sostituire il <blob_service_endpoint> segnaposto con il nome dell'endpoint del servizio BLOB.
- Sostituire il <account_key> segnaposto con la chiave di accesso dell'account.
- Sostituire il <container-name> segnaposto con il nome del contenitore.
- Sostituire il <destination_directory> segnaposto con il nome della directory in cui copiare i dati.
Eseguire un comando list per assicurarsi che il contenitore e la directory siano stati creati.
```
hadoop fs -libjars $azjars \
-D fs.AbstractFileSystem.wasb.Impl=org.apache.hadoop.fs.azure.Wasb \
-D fs.azure.account.key.<blob_service_endpoint>=<account_key> \
-ls -R  wasb://<container_name>@<blob_service_endpoint>/
```
- Sostituire il <blob_service_endpoint> segnaposto con il nome dell'endpoint del servizio BLOB.
- Sostituire il <account_key> segnaposto con la chiave di accesso dell'account.
- Sostituire il <container-name> segnaposto con il nome del contenitore.
Copiare dati da Hadoop HDFS all'archivio BLOB di Data Box nel contenitore creato in precedenza. Se la directory in cui si esegue la copia non viene trovata, il comando lo crea automaticamente.
```
hadoop distcp \
-libjars $azjars \
-D fs.AbstractFileSystem.wasb.Impl=org.apache.hadoop.fs.azure.Wasb \
-D fs.azure.account.key.<blob_service_endpoint<>=<account_key> \
-filters <exclusion_filelist_file> \
[-f filelist_file | /<source_directory> \
       wasb://<container_name>@<blob_service_endpoint>/<destination_directory>
```
- Sostituire il <blob_service_endpoint> segnaposto con il nome dell'endpoint del servizio BLOB.
- Sostituire il <account_key> segnaposto con la chiave di accesso dell'account.
- Sostituire il <container-name> segnaposto con il nome del contenitore.
- Sostituire il <exlusion_filelist_file> segnaposto con il nome del file che contiene l'elenco di esclusioni di file.
- Sostituire il <source_directory> segnaposto con il nome della directory contenente i dati da copiare.
- Sostituire il <destination_directory> segnaposto con il nome della directory in cui copiare i dati.
L'opzione -libjars viene usata per rendere disponibili i hadoop-azure*.jar file dipendenti azure-storage*.jar e .distcp Questo problema può verificarsi già per alcuni cluster.

Nell'esempio seguente viene illustrato come viene usato il distcp comando per copiare i dati.
```
 hadoop distcp \
-libjars $azjars \
-D fs.AbstractFileSystem.wasb.Impl=org.apache.hadoop.fs.azure.Wasb \
-D fs.azure.account.key.mystorageaccount.blob.mydataboxno.microsoftdatabox.com=myaccountkey \
-filter ./exclusions.lst -f /tmp/copylist1 -m 4 \
/data/testfiles \
wasb://hdfscontainer@mystorageaccount.blob.mydataboxno.microsoftdatabox.com/data
```
Per migliorare la velocità di copia:
- Provare a modificare il numero di mapper. Il numero predefinito di mapper è 20. L'esempio precedente usa m = 4 mapper.
- Provare -D fs.azure.concurrentRequestCount.out=<thread_number> . Sostituire <thread_number> con il numero di thread per mapper. Il prodotto del numero di mapper e del numero di thread per mapper, m*<thread_number>, non deve superare 32.
- Provare a eseguire più distcp in parallelo.
- Tenere presente che i file di grandi dimensioni offrono prestazioni migliori rispetto ai file di piccole dimensioni.
- Se sono presenti file di dimensioni superiori a 200 GB, è consigliabile modificare le dimensioni del blocco in 100 MB con i parametri seguenti:
```
hadoop distcp \ 
-libjars $azjars \ 
-Dfs.azure.write.request.size= 104857600 \ 
-Dfs.AbstractFileSystem.wasb.Impl=org.apache.hadoop.fs.azure.Wasb \ 
-Dfs.azure.account.key.<blob_service_endpoint<>=<account_key> \ 
-strategy dynamic \ 
-Dmapreduce.map.memory.mb=16384 \ 
-Dfs.azure.concurrentRequestCount.out=8 \ 
-Dmapreduce.map.java.opts=-Xmx8196m \ 
-m 4 \ 
-update \ 
/data/bigfile wasb://hadoop@mystorageaccount.blob.core.windows.net/bigfile
```

Spedire Data Box a Microsoft

Seguire questa procedura per preparare e spedire il dispositivo Data Box a Microsoft.

Prima di tutto, prepararsi per la spedizione in Data Box o Data Box Heavy.
Al termine della preparazione del dispositivo, scaricare i file DBA. Questi file DBA o manifesto vengono usati in un secondo momento per verificare i dati caricati in Azure.
Arrestare il dispositivo e rimuovere i cavi.
Pianificare un ritiro con UPS.
- Per i dispositivi Data Box, vedere Spedire Data Box.
- Per i dispositivi Data Box Heavy, vedere Spedire Data Box Heavy.
Dopo che Microsoft riceve il dispositivo, è connesso alla rete del data center e i dati vengono caricati nell'account di archiviazione specificato al momento dell'ordine del dispositivo. Verificare in base ai file DBA che tutti i dati vengano caricati in Azure.

Applicare autorizzazioni di accesso a file e directory (solo Data Lake Archiviazione Gen2)

I dati sono già disponibili nell'account Archiviazione di Azure. Ora si applicano le autorizzazioni di accesso ai file e alle directory.

Nota

Questo passaggio è necessario solo se si usa Azure Data Lake Archiviazione Gen2 come archivio dati. Se si usa solo un account di archiviazione BLOB senza spazio dei nomi gerarchico come archivio dati, è possibile ignorare questa sezione.

Creare un'entità servizio per l'account abilitato per Azure Data Lake Archiviazione Gen2

Per creare un'entità servizio, vedere Procedura: Usare il portale per creare un'applicazione Microsoft Entra e un'entità servizio in grado di accedere alle risorse.

Quando si esegue la procedura descritta nella sezione Assegnare l'applicazione a un ruolo dell'articolo, assicurarsi di assegnare il ruolo Collaboratore ai dati del BLOB di archiviazione all'entità servizio.
Quando si eseguono i passaggi descritti nella sezione Ottenere i valori per l'accesso nell'articolo , salvare i valori di ID applicazione e segreto client in un file di testo. Ne hai bisogno presto.

Generare un elenco di file copiati con le relative autorizzazioni

Dal cluster Hadoop locale eseguire questo comando:


sudo -u hdfs ./copy-acls.sh -s /{hdfs_path} > ./filelist.json

Questo comando genera un elenco di file copiati con le relative autorizzazioni.

Nota

A seconda del numero di file in HDFS, questo comando può richiedere molto tempo per l'esecuzione.

Generare un elenco di identità ed eseguirne il mapping alle identità di Microsoft Entra

Scaricare lo copy-acls.py script. Vedere la sezione Scaricare gli script helper e configurare il nodo perimetrale per eseguirli in questo articolo.
Eseguire questo comando per generare un elenco di identità univoche.
```
./copy-acls.py -s ./filelist.json -i ./id_map.json -g
```
Questo script genera un file denominato id_map.json che contiene le identità di cui è necessario eseguire il mapping alle identità basate su ADD.
Aprire il file id_map.json in un editor di testo.
Per ogni oggetto JSON visualizzato nel file, aggiornare l'attributo target di un nome dell'entità utente di Microsoft Entra (UPN) o di ObjectId (OID), con l'identità mappata appropriata. Al termine, salvare il file. Questo file sarà necessario nel passaggio successivo.

Applicare le autorizzazioni ai file copiati e applicare i mapping delle identità

Eseguire questo comando per applicare le autorizzazioni ai dati copiati nell'account abilitato per Data Lake Archiviazione Gen2:

./copy-acls.py -s ./filelist.json -i ./id_map.json  -A <storage-account-name> -C <container-name> --dest-spn-id <application-id>  --dest-spn-secret <client-secret>

Sostituire il segnaposto <storage-account-name> con il nome del proprio account di archiviazione.
Sostituire il <container-name> segnaposto con il nome del contenitore.
Sostituire i <application-id> segnaposto e <client-secret> con l'ID applicazione e il segreto client raccolti al momento della creazione dell'entità servizio.

Appendice: Suddividere i dati tra più dispositivi Data Box

Prima di spostare i dati in un dispositivo Data Box, è necessario scaricare alcuni script helper, assicurarsi che i dati siano organizzati per adattarsi a un dispositivo Data Box ed escludere eventuali file non necessari.

Scaricare gli script helper e configurare il nodo perimetrale per eseguirli

Dal nodo perimetrale o head del cluster Hadoop locale eseguire questo comando:
```
git clone https://github.com/jamesbak/databox-adls-loader.git
cd databox-adls-loader
```
Questo comando clona il repository GitHub che contiene gli script helper.
Assicurarsi che sia il pacchetto jq installato nel computer locale.
```
sudo apt-get install jq
```
Installare il pacchetto Python Richieste .
```
pip install requests
```
Impostare le autorizzazioni di esecuzione per gli script necessari.
```
chmod +x *.py *.sh
```

Assicurarsi che i dati siano organizzati per adattarsi a un dispositivo Data Box

Se le dimensioni dei dati superano le dimensioni di un singolo dispositivo Data Box, è possibile suddividere i file in gruppi che è possibile archiviare in più dispositivi Data Box.

Se i dati non superano le dimensioni di un dispositivo singe Data Box, è possibile passare alla sezione successiva.

Con autorizzazioni elevate, eseguire lo generate-file-list script scaricato seguendo le indicazioni riportate nella sezione precedente.

Ecco una descrizione dei parametri del comando:

sudo -u hdfs ./generate-file-list.py [-h] [-s DATABOX_SIZE] [-b FILELIST_BASENAME]
                 [-f LOG_CONFIG] [-l LOG_FILE]
                 [-v {DEBUG,INFO,WARNING,ERROR}]
                 path

where:
positional arguments:
path                  The base HDFS path to process.

optional arguments:
-h, --help            show this help message and exit
-s DATABOX_SIZE, --databox-size DATABOX_SIZE
                     The size of each Data Box in bytes.
-b FILELIST_BASENAME, --filelist-basename FILELIST_BASENAME
                     The base name for the output filelists. Lists will be
                     named basename1, basename2, ... .
-f LOG_CONFIG, --log-config LOG_CONFIG
                     The name of a configuration file for logging.
-l LOG_FILE, --log-file LOG_FILE
                     Name of file to have log output written to (default is
                     stdout/stderr)
-v {DEBUG,INFO,WARNING,ERROR}, --log-level {DEBUG,INFO,WARNING,ERROR}
                     Level of log information to output. Default is 'INFO'.

Copiare gli elenchi di file generati in HDFS in modo che siano accessibili al processo DistCp .
```
hadoop fs -copyFromLocal {filelist_pattern} /[hdfs directory]
```

Escludere i file non necessari

È necessario escludere alcune directory dal processo DisCp. Ad esempio, escludere directory che contengono informazioni sullo stato che mantengono il cluster in esecuzione.

Nel cluster Hadoop locale in cui si prevede di avviare il processo DistCp creare un file che specifica l'elenco di directory da escludere.

Ecco un esempio:

.*ranger/audit.*
.*/hbase/data/WALs.*

Passaggi successivi

Informazioni sul funzionamento di Data Lake Archiviazione Gen2 con i cluster HDInsight. Per altre informazioni, vedere Usare Azure Data Lake Storage Gen2 con cluster Azure HDInsight.

Condividi tramite