Porta il tuo contenitore (BYOC)

Amazon Braket Hybrid Jobs offre tre contenitori predefiniti per l'esecuzione di codice in ambienti diversi. Se uno di questi contenitori supporta il tuo caso d'uso, devi fornire lo script dell'algoritmo solo quando crei un lavoro ibrido. Le dipendenze minori mancanti possono essere aggiunte dallo script dell'algoritmo o da un requirements.txt file utilizzandopip.

Se nessuno di questi contenitori supporta il tuo caso d'uso o se desideri ampliarli, Braket Hybrid Jobs supporta l'esecuzione di lavori ibridi con la tua immagine del Docker contenitore personalizzata o Bring your own container (BYOC). Ma prima di approfondire, assicuriamoci che sia effettivamente la funzionalità giusta per il tuo caso d'uso.

Quando portare il mio container è la decisione giusta?

Bringing your own container (BYOC) to Braket Hybrid Jobs offre la flessibilità di utilizzare il proprio software installandolo in un ambiente impacchettato. A seconda delle esigenze specifiche, potrebbero esserci modi per ottenere la stessa flessibilità senza dover passare attraverso la BYOC Docker build completa - caricamento Amazon ECR - ciclo URI dell'immagine personalizzata.

Nota

BYOC potrebbe non essere la scelta giusta se si desidera aggiungere un numero limitato di pacchetti Python aggiuntivi (generalmente meno di 10) disponibili pubblicamente. Ad esempio, se stai usando. PyPi

In questo caso, puoi utilizzare una delle immagini Braket predefinite e quindi includere un requirements.txt file nella directory dei sorgenti al momento dell'invio del lavoro. Il file viene letto automaticamente e pip installerà i pacchetti con le versioni specificate come di consueto. Se state installando un gran numero di pacchetti, la durata dei vostri job potrebbe aumentare notevolmente. Controlla la versione Python e, se applicabile, CUDA del contenitore precostruito che desideri utilizzare per verificare se il tuo software funzionerà.

Il BYOC è necessario quando si desidera utilizzare un linguaggio non Python (come C++ o Rust) per lo script di lavoro o se si desidera utilizzare una versione Python non disponibile tramite i contenitori predefiniti di Braket. È anche una buona scelta se:

• Stai utilizzando un software con una chiave di licenza e devi autenticarla con un server di licenza per eseguire il software. Con BYOC, puoi incorporare la chiave di licenza nell'Dockerimmagine e includere il codice per autenticarla.

• Stai utilizzando un software che non è disponibile pubblicamente. Ad esempio, il software è ospitato su un archivio privato GitLab o su un GitHub repository a cui è necessaria una particolare chiave SSH per accedere.

• È necessario installare un'ampia suite di software che non sia inclusa nei contenitori forniti da Braket. Il BYOC ti consentirà di eliminare i lunghi tempi di avvio per i contenitori di lavori ibridi dovuti all'installazione del software.

BYOC vi consente inoltre di mettere a disposizione dei clienti il vostro SDK o algoritmo personalizzato creando un Docker contenitore con il vostro software e rendendolo disponibile agli utenti. Puoi farlo impostando le autorizzazioni appropriate in Amazon ECR.

Nota

È necessario rispettare tutte le licenze software applicabili.

Ricetta per portare il proprio contenitore

In questa sezione, forniamo una step-by-step guida su ciò che ti servirà bring your own container (BYOC) per Braket Hybrid Jobs: gli script, i file e i passaggi per combinarli in modo da iniziare a utilizzare le tue immagini personalizzateDocker. Forniamo ricette per due casi comuni:

1. Installa software aggiuntivo in un'Dockerimmagine e usa solo script di algoritmi Python nei tuoi lavori.

2. Usa script di algoritmi scritti in un linguaggio non Python con Hybrid Jobs o un'architettura CPU diversa da x86.

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 istanze Amazon EC2, quindi esegue Docker l'immagine specificata dall'input URI dell'immagine per la creazione di job su di esse. Quando utilizzi la funzionalità BYOC, specifichi un URI di immagine ospitato in un repository Amazon ECR 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'Dockerimmagine 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 alla Amazon ECR CLIdocumentazione, se necessario, mentre leggi 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 file BYOC potrebbe essereDocker: FROM [IMAGE_URI_HERE]

Quindi, compila il resto 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'architettura CPU non x86, come ARM, potresti dover creare su un'immagine pubblica barebone. Puoi trovare molte di queste immagini nella galleria pubblica di Amazon Elastic Container Registry. Assicurati di sceglierne una adatta all'architettura della CPU e, se necessario, alla GPU che desideri utilizzare.

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

Nota

Se stai solo aggiungendo software aggiuntivo a un'immagine Braket predefinita, puoi saltare questa sezione.

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.

A Dockerfile che installa tutto il software necessario e include lo script del contenitore

Nota

Se utilizzi un'immagine Braket predefinita come immagine di Docker base, lo script del contenitore è già presente.

Se hai creato uno script 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 Jobs accelerate da GPU:

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 per garantire la conformità con tutte le licenze AWS Open-Source pertinenti. Ad esempio, attribuendo correttamente qualsiasi codice installato governato da un. MIT license

Se devi includere codice non pubblico, ad esempio codice ospitato in un GitLab archivio GitHub o in un archivio privato, non incorporare le chiavi SSH nell'immagine per accedervi. Docker Utilizza invece Docker Compose when you build per consentire l'accesso Docker a SSH sulla macchina host su cui è costruito. Per maggiori informazioni, consulta la guida Uso sicuro delle chiavi SSH in Docker per accedere ai repository privati di Github.

DockerCreazione e caricamento della tua immagine

Una volta definito correttamenteDockerfile, sei pronto a seguire i passaggi per creare un repository Amazon ECR 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 Dockerle immagini devono essere ospitate in repository privati di Amazon ECR. Per impostazione predefinita, un repository Amazon ECR privato non fornisce l'accesso in lettura a Braket Hybrid Jobs IAM role o ad altri utenti che desiderano utilizzare la tua immagine, ad esempio un collaboratore o uno studente. È necessario impostare una politica di repository per concedere le autorizzazioni appropriate. In generale, concedi l'autorizzazione solo agli utenti e ai IAM ruoli specifici a cui desideri accedere alle tue immagini, anziché consentire a chiunque li possieda di image URI recuperarle.

Esecuzione dei job ibridi di Braket nel tuo contenitore

Per creare un lavoro ibrido con il tuo contenitore, chiama AwsQuantumJob.create() con l'argomento image_uri specificato. È possibile utilizzare una QPU, un simulatore on-demand o eseguire il codice localmente sul processore classico disponibile con Braket Hybrid Jobs. Ti consigliamo di testare il codice su un simulatore come SV1, DM1 o TN1 prima di eseguirlo su una QPU reale.

Per eseguire il codice sul processore classico, specifica instanceType and the che usi aggiornando ilinstanceCount. InstanceConfig Tieni presente che se specifichi un valore instance_count > 1, devi assicurarti che il codice possa essere eseguito su più host. Il limite massimo per il numero di istanze che puoi scegliere è 5. Per esempio:

job = AwsQuantumJob.create(
    source_module="source_dir",
    entry_point="source_dir.algorithm_script:start_here",
    image_uri="111122223333.dkr.ecr.us-west-2.amazonaws.com/my-byoc-container:latest",
    instance_config=InstanceConfig(instanceType="ml.p3.8xlarge", instanceCount=3),
    device="local:braket/braket.local.qubit",
    # ...)

Nota

Usa l'ARN del dispositivo per tracciare il simulatore che hai usato come metadati di lavoro ibridi. I valori accettabili devono seguire il formato. device = "local:<provider>/<simulator_name>" Ricordatelo <provider> e <simulator_name> deve essere composto solo da lettere, numeri_,-, e.. La stringa è limitata a 256 caratteri.

Se intendi utilizzare BYOC e non utilizzi l'SDK Braket per creare attività quantistiche, dovresti passare il valore della variabile ambientale AMZN_BRAKET_JOB_TOKEN al parametro nella richiesta. jobToken CreateQuantumTask In caso contrario, le attività quantistiche non hanno la priorità e vengono fatturate come normali attività quantistiche autonome.