Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Ricetta per portare il proprio contenitore

In questa sezione, forniamo una step-by-step guida su ciò di cui avrai bisogno bring your own container (BYOC) a Braket Hybrid Jobs: gli script, i file e i passaggi per combinarli in modo da renderli operativi con i tuoi progetti personalizzati Docker immagini. Forniamo ricette per due casi comuni:

La definizione dello script di immissione del contenitore è più complessa nel caso 2.

Quando Braket esegue il tuo Hybrid Job, avvia il numero e il tipo richiesti di EC2 istanze Amazon, quindi esegue Docker immagine specificata dall'immagine URI inserita per la creazione di posti di lavoro su di esse. Quando utilizzi la BYOC funzionalità, specifichi un'immagine URI ospitata in un ECRrepository Amazon privato a cui hai accesso in lettura. Braket Hybrid Jobs utilizza quell'immagine personalizzata per eseguire il lavoro.

I componenti specifici necessari per creare un Docker immagine che può essere utilizzata con Hybrid Jobs. Se non hai familiarità con la scrittura e la creazioneDockerfiles, ti suggeriamo di fare riferimento alla documentazione di Dockerfile e al Amazon ECR CLI la documentazione necessaria durante la lettura di queste istruzioni.

Un'immagine di base per il tuo Dockerfile

Se utilizzi Python e desideri installare software in aggiunta a quanto fornito nei contenitori forniti da Braket, un'opzione per un'immagine di base è una delle immagini del contenitore Braket, ospitate nel nostro GitHub repository e su Amazon. ECR Dovrai autenticarti su Amazon ECR per estrarre l'immagine e crearla su di essa. Ad esempio, la prima riga del tuo BYOC Docker il file potrebbe essere: FROM [IMAGE_URI_HERE]

Quindi, compila il resto del Dockerfile per installare e configurare il software che desideri aggiungere al contenitore. Le immagini Braket predefinite conterranno già lo script del punto di ingresso del contenitore appropriato, quindi non devi preoccuparti di includerlo.

Se vuoi usare un linguaggio non Python, come C++, Rust o Julia, o se vuoi creare un'immagine per un'CPUarchitettura non x86, ad esempioARM, potresti dover creare su un'immagine pubblica scarna. Puoi trovare molte di queste immagini nella galleria pubblica di Amazon Elastic Container Registry. Assicurati di sceglierne una adatta all'CPUarchitettura e, se necessario, a quella che GPU desideri utilizzare.

(Facoltativo) Uno script modificato per il punto di ingresso del contenitore

Per eseguire codice non Python come parte del tuo lavoro ibrido, dovrai modificare lo script Python che definisce il punto di ingresso del contenitore. Ad esempio, lo script braket_container.py python su Amazon Braket Github. Questo è lo script utilizzato dalle immagini predefinite da Braket per avviare lo script dell'algoritmo e impostare le variabili di ambiente appropriate. Lo script del punto di ingresso del contenitore stesso deve essere in Python, ma può avviare script non Python. Nell'esempio predefinito, puoi vedere che gli script degli algoritmi Python vengono avviati come sottoprocesso Python o come processo completamente nuovo. Modificando questa logica, è possibile abilitare lo script del punto di ingresso per avviare script di algoritmi non Python. Ad esempio, è possibile modificare la thekick_off_customer_script()funzione per avviare i processi Rust in base alla fine dell'estensione del file.

Puoi anche scegliere di scriverne uno completamente nuovobraket_container.py. Dovrebbe copiare i dati di input, gli archivi di origine e altri file necessari da Amazon S3 nel contenitore e definire le variabili di ambiente appropriate.

Installa il software e lo script del contenitore necessari con Dockerfile

Se hai creato uno script del contenitore modificato nel passaggio precedente, dovrai copiarlo nel contenitore e definire la variabile di ambiente o il nome che hai dato SAGEMAKER_PROGRAM al braket_container.py nuovo script del punto di ingresso del contenitore.

Di seguito è riportato un esempio Dockerfile che consente di utilizzare Julia su istanze di Jobs GPU con accelerazione:

FROM nvidia/cuda:12.2.0-devel-ubuntu22.04

    
 ARG DEBIAN_FRONTEND=noninteractive
 ARG JULIA_RELEASE=1.8
 ARG JULIA_VERSION=1.8.3


 ARG PYTHON=python3.11 
 ARG PYTHON_PIP=python3-pip
 ARG PIP=pip


 ARG JULIA_URL = https://julialang-s3.julialang.org/bin/linux/x64/${JULIA_RELEASE}/
 ARG TAR_NAME = julia-${JULIA_VERSION}-linux-x86_64.tar.gz


 ARG PYTHON_PKGS = # list your Python packages and versions here


 RUN curl -s -L ${JULIA_URL}/${TAR_NAME} | tar -C /usr/local -x -z --strip-components=1 -f -


 RUN apt-get update \

    && apt-get install -y --no-install-recommends \

    build-essential \

    tzdata \

    openssh-client \

    openssh-server \

    ca-certificates \

    curl \

    git \

    libtemplate-perl \

    libssl1.1 \

    openssl \

    unzip \ 

    wget \

    zlib1g-dev \

    ${PYTHON_PIP} \

    ${PYTHON}-dev \




 RUN ${PIP} install --no-cache --upgrade ${PYTHON_PKGS}


 RUN ${PIP} install --no-cache --upgrade sagemaker-training==4.1.3


 # Add EFA and SMDDP to LD library path
 ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
 ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH


 # Julia specific installation instructions
 COPY Project.toml /usr/local/share/julia/environments/v${JULIA_RELEASE}/
 RUN JULIA_DEPOT_PATH=/usr/local/share/julia \

    julia -e 'using Pkg; Pkg.instantiate(); Pkg.API.precompile()'
 # generate the device runtime library for all known and supported devices
 RUN JULIA_DEPOT_PATH=/usr/local/share/julia \

    julia -e 'using CUDA; CUDA.precompile_runtime()'


 # Open source compliance scripts
 RUN HOME_DIR=/root \

 && curl -o ${HOME_DIR}/oss_compliance.zip https://aws-dlinfra-utilities.s3.amazonaws.com/oss_compliance.zip \

 && unzip ${HOME_DIR}/oss_compliance.zip -d ${HOME_DIR}/ \

 && cp ${HOME_DIR}/oss_compliance/test/testOSSCompliance /usr/local/bin/testOSSCompliance \

 && chmod +x /usr/local/bin/testOSSCompliance \

 && chmod +x ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh \

 && ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh ${HOME_DIR} ${PYTHON} \

 && rm -rf ${HOME_DIR}/oss_compliance*


 # Copying the container entry point script
 COPY braket_container.py /opt/ml/code/braket_container.py
 ENV SAGEMAKER_PROGRAM braket_container.py

Questo esempio scarica ed esegue gli script forniti da AWS per garantire la conformità con tutte le licenze Open-Source pertinenti. Ad esempio, attribuendo correttamente qualsiasi codice installato governato da un MIT license.

Se è necessario includere codice non pubblico, ad esempio codice ospitato in un GitLab archivio GitHub o in un archivio privato, non incorporare SSH chiavi in Docker immagine per accedervi. Invece, usa Docker Compose quando costruisci per consentire Docker per accedere alla macchina host SSH su cui è basato. Per ulteriori informazioni, consulta la guida Uso sicuro delle SSH chiavi in Docker per accedere ai repository privati di Github.

Creazione e caricamento del tuo Docker immagine

Una volta definito correttamenteDockerfile, ora sei pronto a seguire i passaggi per creare un ECR repository Amazon privato, se non ne esiste già uno. Puoi anche creare, etichettare e caricare l'immagine del contenitore nel repository.

Sei pronto per creare, etichettare e inserire l'immagine. Consulta la documentazione della build di Docker per una spiegazione completa delle opzioni docker build e alcuni esempi.

Per il file di esempio sopra definito, puoi eseguire:

aws ecr get-login-password --region ${your_region} | docker login --username AWS --password-stdin ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com
 docker build -t braket-julia .
 docker tag braket-julia:latest ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest
 docker push ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest

Assegnazione delle autorizzazioni Amazon ECR appropriate

Braket Hybrid Jobs Docker le immagini devono essere ospitate in ECR repository privati di Amazon. Per impostazione predefinita, un ECR repository Amazon privato non fornisce l'accesso in lettura a Braket Hybrid Jobs IAM role o a qualsiasi altro utente che desideri utilizzare la tua immagine, ad esempio un collaboratore o uno studente. È necessario impostare una politica di archiviazione per concedere le autorizzazioni appropriate. In generale, concedi l'autorizzazione solo a quegli utenti specifici e IAM ruoli in cui desideri accedere alle tue immagini, anziché consentire a chiunque disponga di image URI per tirarli.