Usare Azure Pipelines per compilare e distribuire una soluzione HPC
Gli strumenti di Azure DevOps possono automatizzare la creazione e il test Azure Batch soluzioni HPC (High Performance Computing). Azure Pipelines offre processi moderni di integrazione continua (CI) e distribuzione continua (CD) per la compilazione, la distribuzione, il test e il monitoraggio del software. Questi processi accelerano la distribuzione del software, consentendo di concentrarsi sul codice anziché supportare l'infrastruttura e le operazioni.
Questo articolo illustra come configurare i processi CI/CD usando Azure Pipelines con i modelli di Azure Resource Manager (modelli arm) per distribuire soluzioni HPC in Azure Batch. Nell'esempio viene creata una pipeline di compilazione e rilascio per distribuire un'infrastruttura Azure Batch e rilasciare un pacchetto dell'applicazione. Il diagramma seguente mostra il flusso di distribuzione generale, presupponendo che il codice venga sviluppato in locale:
Prerequisiti
Per seguire la procedura descritta in questo articolo, è necessario:
Un'organizzazione Azure DevOps e un progetto Azure DevOps con un repository Azure Repos creato nell'organizzazione. È necessario disporre di ruoli Amministratore progetto, Amministratore compilazione e Amministratore versione nel progetto Azure DevOps.
Sottoscrizione di Azure attiva con proprietario o altro ruolo che include le capacità di assegnazione del ruolo. Per altre informazioni, vedere Informazioni sulle assegnazioni di ruolo di Azure.
Conoscenza di base della sintassi del modello di Controllo del codice sorgente e arm.
Preparare la soluzione
L'esempio in questo articolo usa diversi modelli di Resource Manager e un'applicazione di elaborazione video open source esistente, FFmpeg. È possibile copiare o scaricare queste risorse e eseguirne il push nel repository di Azure Repos.
Importante
In questo esempio viene distribuito il software Windows nei nodi Batch basati su Windows. Azure Pipelines, modelli arm e Batch supportano anche completamente software e nodi Linux.
Informazioni sui modelli di Resource Manager
Tre modelli di funzionalità, simili a unità o moduli, implementano parti specifiche di funzionalità. Un modello di soluzione end-to-end distribuisce quindi i modelli di funzionalità sottostanti. Questa struttura del modello collegato consente a ogni modello di funzionalità di essere testato singolarmente e riutilizzato tra soluzioni.
Per informazioni dettagliate sui modelli, vedere la guida di riferimento Resource Manager modello per i tipi di risorse Microsoft.Batch.
Modello di account di archiviazione
Salvare il codice seguente come file denominato storageAccount.json. Questo modello definisce un account di archiviazione di Azure, necessario per distribuire l'applicazione nell'account Batch.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"accountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Storage Account"
}
}
},
"variables": {},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"name": "[parameters('accountName')]",
"sku": {
"name": "Standard_LRS"
},
"apiVersion": "2018-02-01",
"location": "[resourceGroup().location]",
"properties": {}
}
],
"outputs": {
"blobEndpoint": {
"type": "string",
"value": "[reference(resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))).primaryEndpoints.blob]"
},
"resourceId": {
"type": "string",
"value": "[resourceId('Microsoft.Storage/storageAccounts', parameters('accountName'))]"
}
}
}
Modello di account Batch
Salvare il codice seguente come file denominato batchAccount.json. Questo modello definisce un account Batch. L'account Batch funge da piattaforma per eseguire applicazioni tra pool di nodi.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"batchAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account"
}
},
"storageAccountId": {
"type": "string",
"metadata": {
"description": "ID of the Azure Storage Account"
}
}
},
"variables": {},
"resources": [
{
"name": "[parameters('batchAccountName')]",
"type": "Microsoft.Batch/batchAccounts",
"apiVersion": "2017-09-01",
"location": "[resourceGroup().location]",
"properties": {
"poolAllocationMode": "BatchService",
"autoStorage": {
"storageAccountId": "[parameters('storageAccountId')]"
}
}
}
],
"outputs": {}
}
Modello di pool batch
Salvare il codice seguente come file denominato batchAccountPool.json. Questo modello crea un pool di nodi e nodi nell'account Batch.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"batchAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account"
}
},
"batchAccountPoolName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account Pool"
}
}
},
"variables": {},
"resources": [
{
"name": "[concat(parameters('batchAccountName'),'/', parameters('batchAccountPoolName'))]",
"type": "Microsoft.Batch/batchAccounts/pools",
"apiVersion": "2017-09-01",
"properties": {
"deploymentConfiguration": {
"virtualMachineConfiguration": {
"imageReference": {
"publisher": "MicrosoftWindowsServer",
"offer": "WindowsServer",
"sku": "2022-datacenter",
"version": "latest"
},
"nodeAgentSkuId": "batch.node.windows amd64"
}
},
"vmSize": "Standard_D2s_v3"
}
}
],
"outputs": {}
}
Modello di Orchestrator
Salvare il codice seguente come file denominato deployment.json. Questo modello finale funge da agente di orchestrazione per distribuire i tre modelli di funzionalità sottostanti.
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"StorageContainerUri": {
"type": "string",
"metadata": {
"description": "URI of the Blob Storage Container containing the Azure Resource Manager templates"
}
},
"StorageContainerSasToken": {
"type": "string",
"metadata": {
"description": "The SAS token of the container containing the Azure Resource Manager templates"
}
},
"applicationStorageAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Storage Account"
}
},
"batchAccountName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account"
}
},
"batchAccountPoolName": {
"type": "string",
"metadata": {
"description": "Name of the Azure Batch Account Pool"
}
}
},
"variables": {},
"resources": [
{
"apiVersion": "2017-05-10",
"name": "storageAccountDeployment",
"type": "Microsoft.Resources/deployments",
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/storageAccount.json', parameters('StorageContainerSasToken'))]",
"contentVersion": "1.0.0.0"
},
"parameters": {
"accountName": {"value": "[parameters('applicationStorageAccountName')]"}
}
}
},
{
"apiVersion": "2017-05-10",
"name": "batchAccountDeployment",
"type": "Microsoft.Resources/deployments",
"dependsOn": [
"storageAccountDeployment"
],
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccount.json', parameters('StorageContainerSasToken'))]",
"contentVersion": "1.0.0.0"
},
"parameters": {
"batchAccountName": {"value": "[parameters('batchAccountName')]"},
"storageAccountId": {"value": "[reference('storageAccountDeployment').outputs.resourceId.value]"}
}
}
},
{
"apiVersion": "2017-05-10",
"name": "poolDeployment",
"type": "Microsoft.Resources/deployments",
"dependsOn": [
"batchAccountDeployment"
],
"properties": {
"mode": "Incremental",
"templateLink": {
"uri": "[concat(parameters('StorageContainerUri'), 'arm-templates/batchAccountPool.json', parameters('StorageContainerSasToken'))]",
"contentVersion": "1.0.0.0"
},
"parameters": {
"batchAccountName": {"value": "[parameters('batchAccountName')]"},
"batchAccountPoolName": {"value": "[parameters('batchAccountPoolName')]"}
}
}
}
],
"outputs": {}
}
Configurare il repository
Caricare i modelli arm, l'app FFmpeg e un file di definizione di compilazione YAML nel repository di Azure Repos.
Caricare i quattro modelli di Resource Manager in una cartella arm-templates nel repository.
Per il pacchetto dell'applicazione, scaricare ed estrarre la versione a 64 bit di FFmpeg 4.3.1 e caricarla in una cartella hpc-application nel repository.
Per la definizione di compilazione, salvare la definizione seguente come file denominato hpc-app.build.yml e caricarlo in una cartella pipeline nel repository.
# To publish an application into Batch, you need to # first zip the file, and then publish an artifact, so # you can take the necessary steps in your release pipeline. steps: # First, zip up the files required in the Batch account. # For this instance, those are the ffmpeg files. - task: ArchiveFiles@2 displayName: 'Archive applications' inputs: rootFolderOrFile: hpc-application includeRootFolder: false archiveFile: '$(Build.ArtifactStagingDirectory)/package/$(Build.BuildId).zip' # Publish the zip file, so you can use it as part # of your Release pipeline later. - task: PublishPipelineArtifact@0 inputs: artifactName: 'hpc-application' targetPath: '$(Build.ArtifactStagingDirectory)/package'
Al termine della configurazione del repository, la struttura delle cartelle deve avere le sezioni principali seguenti:
- Cartella arm-templates che contiene i modelli di Resource Manager.
- Cartella hpc-application contenente ffmpeg.
- Cartella pipeline che contiene il file di definizione di compilazione YAML per la pipeline di compilazione.
Nota
Questa struttura codebase di esempio illustra che è possibile archiviare il codice dell'applicazione, dell'infrastruttura e della pipeline nello stesso repository.
Creare la pipeline di Azure
Dopo aver configurato il repository del codice sorgente, usare Azure Pipelines per implementare una pipeline di compilazione, test e distribuzione per l'applicazione. In questa fase di una pipeline vengono in genere eseguiti test per convalidare il codice e compilare parti del software. Il numero e i tipi di test e qualsiasi altra attività eseguita dipendono dalla strategia generale di compilazione e rilascio.
Creare la pipeline di compilazione
In questa sezione viene creata una pipeline di compilazione YAML per l'uso del software ffmpeg eseguito nell'account Batch.
Nel progetto Azure DevOps selezionare Pipeline nel riquadro di spostamento a sinistra e quindi selezionare Nuova pipeline.
Nella schermata Where is your code (Dove è il codice) selezionare Azure Repos Git.
Nella schermata Seleziona un repository selezionare il repository.
Nota
È anche possibile creare una pipeline di compilazione usando una finestra di progettazione visiva. Nella pagina Nuova pipeline selezionare Usa l'editor classico. È possibile usare un modello YAML nella finestra di progettazione visiva. Per altre informazioni, vedere Definire la pipeline classica.
Nella schermata Configura pipeline selezionareFile YAML di Azure Pipelines esistente.
Nella schermata Seleziona un file YAML esistente selezionare il file hpc-app.build.yml dal repository e quindi selezionare Continua.
Nella schermata Verifica YAML della pipeline esaminare la configurazione di compilazione e quindi selezionare Esegui oppure selezionare l'elenco a discesa accanto a Esegui e selezionare Salva. Questo modello abilita l'integrazione continua, quindi la compilazione attiva automaticamente quando un nuovo commit nel repository soddisfa le condizioni impostate nella compilazione.
È possibile visualizzare gli aggiornamenti dello stato di avanzamento della compilazione live. Per visualizzare i risultati della compilazione, selezionare l'esecuzione appropriata dalla definizione di compilazione in Azure Pipelines.
Nota
Se si usa un'applicazione client per eseguire la soluzione HPC, è necessario creare una definizione di compilazione separata per tale applicazione. Per le guide su come, vedere la documentazione di Azure Pipelines .
Creare la pipeline di versione
Si usa una pipeline di versione di Azure Pipelines per distribuire l'applicazione e l'infrastruttura sottostante. Le pipeline di rilascio abilitano il CD e automatizzano il processo di rilascio. Esistono diversi passaggi per distribuire l'applicazione e l'infrastruttura sottostante.
I modelli collegati per questa soluzione devono essere accessibili da un endpoint HTTP o HTTPS pubblico. Questo endpoint può essere un repository GitHub, un account Archiviazione BLOB di Azure o un altro percorso di archiviazione. Per assicurarsi che gli artefatti del modello caricati rimangano sicuri, tenerli in modalità privata, ma accedervi usando una forma di token di firma di accesso condiviso (SAS).
Nell'esempio seguente viene illustrato come distribuire un'infrastruttura e un'applicazione usando modelli da un BLOB di Archiviazione di Azure.
Configurare la pipeline
Nel progetto Azure DevOps selezionare Pipelines>Release nel riquadro di spostamento a sinistra.
Nella schermata successiva selezionare Nuova>pipeline di versione.
Nella schermata Seleziona un modello selezionareProcesso vuoto e quindi chiudere la schermata Fase .
Selezionare Nuova pipeline di versione nella parte superiore della pagina e rinominare la pipeline in un elemento pertinente per la pipeline, ad esempio Distribuisci Azure Batch + Pool.
Nella sezione Artefatti selezionare Aggiungi.
Nella schermata Aggiungi un artefatto selezionare Compila e quindi selezionare la pipeline di compilazione per ottenere l'output per l'applicazione HPC.
Nota
È possibile creare un alias di origine o accettare il valore predefinito. Prendere nota del valore dell'alias di origine , perché è necessario creare attività nella definizione della versione.
Selezionare Aggiungi.
Nella pagina della pipeline selezionare Aggiungi accanto a Artefatti per creare un collegamento a un altro artefatto, il repository Azure Repos. Questo collegamento è necessario per accedere ai modelli di Resource Manager nel repository. I modelli di Resource Manager non devono essere compilati, quindi non è necessario eseguirne il push tramite una pipeline di compilazione.
Nota
Si noti nuovamente il valore dell'alias di origine da usare in un secondo momento.
Selezionare la scheda Variabili . Creare le variabili seguenti nella pipeline in modo che non sia necessario immettere nuovamente le stesse informazioni in più attività.
Nome valore applicationStorageAccountName Nome dell'account di archiviazione per contenere i file binari dell'applicazione HPC. batchAccountApplicationName Nome dell'applicazione nell'account Batch. batchAccountName Nome dell'account Batch. batchAccountPoolName Nome per il pool di macchine virtuali (VM) per eseguire l'elaborazione. batchApplicationId ID univoco per l'applicazione Batch, del modulo: /subscriptions/<subscriptionId>/resourceGroups/<resourceGroupName>^/providers/Microsoft.Batch/batchAccounts/<batchAccountName>^/applications/<batchAccountApplicationName>.
Sostituire il segnaposto con l'ID<subscriptionId>sottoscrizione di Azure e gli altri segnaposto con i valori impostati per le altre variabili in questo elenco.batchApplicationVersion Versione semantica dell'applicazione Batch, in questo caso 4.3.1. location Area di Azure per la distribuzione delle risorse. resourceGroupName Nome per il gruppo di risorse in cui distribuire le risorse. storageAccountName Nome dell'account di archiviazione per contenere i modelli di Resource Manager collegati. StorageContainerSasToken $(<referenceName>.StorageContainerSasToken). Sostituire il segnaposto con il<referenceNamevalore nome riferimento configurato nella sezione Variabili di output del passaggio Copia file di Azure seguente.StorageContainerUri $(<referenceName>.StorageContainerUri). Sostituire il segnaposto con il<referenceName>valore del nome di riferimento configurato nella sezione Variabili di output del passaggio Copia file di Azure.
Selezionare la scheda Attività e quindi selezionare Processo agente.
Nella schermata Processo agente selezionare Azure Pipelines in Pool di agenti.
In Specifica agente selezionare windows-latest.
Aggiungere attività
Creare sei attività per:
- Scaricare i file ffmpeg compressi.
- Distribuire un account di archiviazione per ospitare i modelli di Resource Manager annidati.
- Copiare i modelli di Resource Manager nell'account di archiviazione.
- Distribuire l'account Batch e le dipendenze necessarie.
- Creare un'applicazione nell'account Batch.
- Caricare il pacchetto dell'applicazione nell'account Batch.
Per ogni nuova attività specificata dalla procedura seguente:
Selezionare il + simbolo accanto al processo agent nel riquadro sinistro.
Cercare e selezionare l'attività specificata nel riquadro destro.
Aggiungere o selezionare le proprietà per configurare l'attività.
Selezionare Aggiungi.
Creare le attività come indicato di seguito:
Selezionare l'attività Download Pipeline Artifacts e impostare le proprietà seguenti:
- Nome visualizzato: immettere Download ApplicationPackage to Agent.
- Nome artefatto: immettere hpc-application.
- Directory di destinazione: immettere
$(System.DefaultWorkingDirectory).
Creare un account di Archiviazione di Azure per archiviare i modelli di Resource Manager. È possibile usare un account di archiviazione esistente, ma per supportare questo esempio autonomo e l'isolamento del contenuto, creare un account di archiviazione dedicato.
Selezionare la distribuzione del modello di Resource Manager: attività ambito gruppo di risorse e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Distribuisci account di archiviazione per i modelli di Resource Manager.
- Connessione di Azure Resource Manager: selezionare la sottoscrizione di Azure appropriata.
- Sottoscrizione: Selezionare la sottoscrizione di Azure appropriata.
- Azione: selezionare Crea o aggiorna gruppo di risorse.
- Gruppo di risorse: immettere
$(resourceGroupName). - Posizione: immettere
$(location). - Modello: immettere
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/storageAccount.json. Sostituire il segnaposto con l'alias<AzureRepoArtifactSourceAlias>origine del repository annotato in precedenza. - Esegui override dei parametri del modello: immettere
-accountName $(storageAccountName).
Caricare gli artefatti dal controllo del codice sorgente nell'account di archiviazione. Parte di questa attività Copia file di Azure restituisce l'URI del contenitore dell'account di archiviazione e il token di firma di accesso condiviso in una variabile, in modo che possano essere riutilizzati nei passaggi successivi.
Selezionare l'attività Copia file di Azure e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Copia file di AzureBlob.
- Fonte: Immettere
$(System.ArtifactsDirectory)/<AzureRepoArtifactSourceAlias>/arm-templates/. Sostituire il segnaposto con l'alias<AzureRepoArtifactSourceAlias>origine del repository annotato in precedenza. - Sottoscrizione di Azure: Selezionare la sottoscrizione di Azure appropriata.
- Tipo di destinazione: selezionare BLOB di Azure.
- Account di archiviazione RM: immettere
$(storageAccountName). - Nome contenitore: immettere modelli.
- Nome di riferimento: espandere Variabili di output, quindi immettere ffmpeg.
Nota
Se questo passaggio ha esito negativo, assicurarsi che l'organizzazione Azure DevOps disponga del ruolo Collaboratore BLOB di archiviazione nell'account di archiviazione.
Distribuire il modello arm dell'agente di orchestrazione per creare l'account e il pool batch. Questo modello include parametri per l'URI del contenitore dell'account di archiviazione e il token di firma di accesso condiviso. Le variabili necessarie nel modello arm vengono mantenute nella sezione variabili della definizione della versione e sono state impostate dall'attività Copia file di AzureBlob.
Selezionare la distribuzione del modello di Resource Manager: attività ambito gruppo di risorse e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Distribuisci Azure Batch.
- Connessione di Azure Resource Manager: selezionare la sottoscrizione di Azure appropriata.
- Sottoscrizione: Selezionare la sottoscrizione di Azure appropriata.
- Azione: selezionare Crea o aggiorna gruppo di risorse.
- Gruppo di risorse: immettere
$(resourceGroupName). - Posizione: immettere
$(location). - Percorso modello: selezionare l'URL del file.
- Collegamento modello: Immettere
$(StorageContainerUri)arm-templates/deployment.json$(StorageContainerSasToken). - Esegui override dei parametri del modello: immettere
-StorageContainerUri $(StorageContainerUri) -StorageContainerSasToken $(StorageContainerSasToken) -applicationStorageAccountName $(applicationStorageAccountName) -batchAccountName $(batchAccountName) -batchAccountPoolName $(batchAccountPoolName).
Una procedura comune consiste nell'usare le attività di Azure Key Vault. Se l'entità servizio connessa alla sottoscrizione di Azure ha un set di criteri di accesso appropriato, può scaricare i segreti da Key Vault e essere usato come variabile nella pipeline. Il nome del segreto viene impostato con il valore associato. Ad esempio, è possibile fare riferimento a un segreto di sshPassword con $(sshPassword) nella definizione di versione.
Chiamare l'interfaccia della riga di comando di Azure per creare un'applicazione in Azure Batch.
Selezionare l'attività dell'interfaccia della riga di comando di Azure e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Crea applicazione in Azure Batch account.
- Connessione di Azure Resource Manager: selezionare la sottoscrizione di Azure appropriata.
- Tipo di script: selezionare PowerShell Core.
- Percorso script: selezionare script inline.
- Script inline: immettere
az batch application create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName).
Chiamare l'interfaccia della riga di comando di Azure per caricare pacchetti associati all'applicazione, in questo caso i file ffmpeg.
Selezionare l'attività dell'interfaccia della riga di comando di Azure e impostare le proprietà seguenti:
- Nome visualizzato: Immettere Carica pacchetto in Azure Batch account.
- Connessione di Azure Resource Manager: selezionare la sottoscrizione di Azure appropriata.
- Tipo di script: selezionare PowerShell Core.
- Percorso script: selezionare script inline.
- Script inline: immettere
az batch application package create --application-name $(batchAccountApplicationName) --name $(batchAccountName) --resource-group $(resourceGroupName) --version $(batchApplicationVersion) --package-file=$(System.DefaultWorkingDirectory)/$(Release.Artifacts.<AzureBuildArtifactSourceAlias>.BuildId).zip. Sostituire il segnaposto con l'alias<AzureBuildArtifactSourceAlias>origine di compilazione annotato in precedenza.
Nota
il numero di versione del pacchetto dell'applicazione è impostato su una variabile. La variabile consente di sovrascrivere le versioni precedenti del pacchetto e consente di controllare manualmente la versione del pacchetto eseguita in Azure Batch.
Creare ed eseguire la versione
Al termine della creazione di tutti i passaggi, selezionare Salva nella parte superiore della pagina della pipeline e quindi selezionare OK.
Selezionare Crea versione nella parte superiore della pagina.
Per visualizzare lo stato della versione live, selezionare il collegamento nella parte superiore della pagina che indica che è stata creata la versione.
Per visualizzare l'output del log dall'agente, passare il puntatore del mouse sulla fase e quindi selezionare il pulsante Log .
Testare l'ambiente
Dopo aver configurato l'ambiente, verificare che i test seguenti vengano eseguiti correttamente. Sostituire i segnaposto con i valori del gruppo di risorse e dell'account Batch.
Connettersi all'account Batch
Connettersi al nuovo account Batch usando l'interfaccia della riga di comando di Azure da un prompt dei comandi.
- Accedere all'account Azure con
az logine seguire le istruzioni per l'autenticazione. - Autenticare l'account Batch con
az batch account login -g <resourceGroup> -n <batchAccount>.
Elencare le applicazioni disponibili
az batch application list -g <resourceGroup> -n <batchAccount>
Verificare che il pool sia valido
az batch pool list
Nell'output del comando prendere nota del valore di currentDedicatedNodes da modificare nel test successivo.
Ridimensionare il pool
Eseguire il comando seguente per ridimensionare il pool in modo che siano disponibili nodi di calcolo per il processo e il test delle attività. Sostituire il segnaposto con il <poolName> valore del nome del pool e il <targetNumber> segnaposto con un numero maggiore rispetto all'output currentDedicatedNodes del comando precedente. Controllare lo stato eseguendo il az batch pool list comando fino al completamento del ridimensionamento e viene visualizzato il numero di nodi di destinazione.
az batch pool resize --pool-id <poolname> --target-dedicated-nodes <target number>
Passaggi successivi
Vedere queste esercitazioni per informazioni su come interagire con un account Batch tramite un'applicazione semplice.