Apri una shell container (SSH) ed esegui i comandi in Servizio app di Azure

App Service fornisce accesso SSH tramite browser alle app ospitate in container personalizzati di Windows. Non è richiesta alcuna configurazione speciale dell'immagine per la sessione browser.

Il comando interfaccia della riga di comando di Azure az webapp exec è supportato solo per le app web Linux. Non usare gli esempi di CLI Linux presenti in questo articolo per i piani app di Windows Service.

Per container Linux integrati e personalizzati, il terminale del browser più recente e az webapp exec usano Kudu come proxy autenticato per connettersi al container in esecuzione. Queste opzioni non richiedono di installare un server SSH, incorporare una password SSH, esporre una porta SSH o avviare un daemon SSH nella tua immagine personalizzata. L'accesso legacy a Kudu WebSSH e az webapp ssh potrebbe comunque richiedere un server SSH in un'immagine personalizzata.

Usa il portale Azure per una sessione del browser, oppure usa il comando di anteprima az webapp exec per una sessione in un terminale locale o un'esecuzione di comandi in modalità disconnessa. Il terminale del browser richiede /bin/bash nell'immagine e attualmente non supporta la selezione di un'altra shell. Se l'immagine ha una shell diversa, usa az webapp exec --shell /bin/sh invece. Le immagini senza shell, incluse le immagini distroless, non possono aprire una sessione interattiva.

• Per gli esempi di CLI, installa interfaccia della riga di comando di Azure 2.90.0 o successiva e accedi. Verifica la tua versione con az version. Puoi anche usare Azure Cloud Shell se la sua CLI soddisfa questo requisito.
• Per una sessione interattiva CLI, usa un terminale interattivo e una shell che esiste nella tua immagine. Il valore predefinito è /bin/bash; per un'immagine senza bash, specificare --shell /bin/sh se quella shell è disponibile.

Aprire una sessione SSH con l'interfaccia della riga di comando di Azure

Il comando az webapp exec preview apre una shell interattiva nel contenitore principale della tua app. La sessione utilizza il tuo terminale locale su Windows, macOS e Linux; non apre un browser.

az webapp exec --resource-group <resource-group-name> --name <app-name>

Per un'immagine che usa /bin/sh invece di bash:

az webapp exec --resource-group <resource-group-name> --name <app-name> --shell /bin/sh

Puoi eseguire comandi e ispezionare il loro output in questa sessione. Ad esempio, usa top se è installato nell'immagine di sistema. Per ispezionare il container SCM/Kudu invece del container dell'app:

az webapp exec --resource-group <resource-group-name> --name <app-name> --target kudu

L'app e i container Kudu sono ambienti diversi. Esegui comandi che dipendono dal runtime della tua app, dalle dipendenze o dalla connettività di rete nel container dell'app.

Seleziona un'istanza o uno slot di distribuzione

Di default, la CLI si collega a un'unica istanza dell'app. Per trovare gli ID delle istanza:

az webapp list-instances --resource-group <resource-group-name> --name <app-name> --output table

Per collegarsi a un'istanza specifica:

az webapp exec --resource-group <resource-group-name> --name <app-name> --instance <instance-id>

Aggiungi --slot <slot-name> per accedere a uno slot di deployment. Quando selezioni l'istanza di uno slot, aggiungi --slot anche a az webapp list-instances.

La modalità shell interattiva supporta solo un'istanza alla volta.

Esegui comandi senza una sessione interattiva

Usa --mode execute per inviare un comando al container principale dell'app senza aprire una sessione terminale. Il comando viene eseguito in background. Questa modalità è utile per diagnostiche di background o altri lavori che non richiedono un output immediato.

Esegui un programma direttamente

Usa --command per specificare un programma e i suoi argomenti. Racchiudi tra virgolette l'intero comando:

az webapp exec --resource-group <resource-group-name> --name <app-name> --mode execute --command "python3 /home/site/wwwroot/scripts/diagnostics.py" --working-directory /home/site/wwwroot --instance <instance-id>

Sostituisci il percorso dello script con uno script distribuito nella tua app. L'eseguibile e le sue dipendenze devono esistere nel container.

--command non interpreta operatori shell come >, |, o &&. Usalo --shell-command invece quando ti serve una shell. Queste due opzioni sono mutuamente esclusive.

Acquisisci l'output e verifica il completamento

L'esempio seguente utilizza il quoting del client Bash, come in Cloud Shell. Invia un comando diagnostico di sola lettura a una sola istanza e registra separatamente l'output e il codice di uscita. Sostituisci <run-id> con un nuovo identificatore per ogni invocazione e <instance-id> con un ID da az webapp list-instances.

az webapp exec --resource-group <resource-group-name> --name <app-name> \
  --mode execute --instance <instance-id> --shell /bin/sh \
  --shell-command 'uname -a > /home/LogFiles/diagnostics-<run-id>.log 2>&1; result=$?; printf "%s\n" "$result" > /home/LogFiles/diagnostics-<run-id>.exit'

Assicurati che /bin/sh e il comando diagnostico esistano e che /home/LogFiles esista e sia scrivibile. La persistenza di /home nei contenitori personalizzati dipende dalla configurazione di archiviazione dell'app. Le virgolette singole impediscono alla shell del client di espandere $? e $result prima che la richiesta raggiunga il container.

Dopo l'invio, apri una shell interattiva sulla stessa istanza e ispeziona i file:

cat /home/LogFiles/diagnostics-<run-id>.log
cat /home/LogFiles/diagnostics-<run-id>.exit

Uno stato di uscita registrato di 0 indica che il comando diagnostico ha avuto successo. Uno stato diverso da zero indica fallimento; ispezionare il log. Se il file di stato non esiste, il completamento non è stato stabilito: il comando potrebbe ancora essere in esecuzione, potrebbe non essere iniziato o potrebbe essere stato interrotto. Non dedurre il successo dall'accettazione o dalla presenza di un log parziale. Usa un identificatore univoco dell'esecuzione così un vecchio file di stato non può essere confuso con il risultato attuale.

La CLI non fornisce un'API di completion-polling. Reindirizzare l'output a un file non lo rende automaticamente disponibile nello streaming di log degli App Service.

Per migrazioni di database o altre operazioni che cambiano stato condiviso, seleziona un'istanza , controlla il completamento separatamente e non rieseguire l'operazione solo perché la sottomissione non ha restituito alcun output. Mantieni il flusso di lavoro interattivo quando devi verificare l'esito prima di continuare.

Esegui comandi indipendenti su più istanze

La modalità esecuzione accetta anche un elenco di ID istanza separati da virgole o --instance all. Le richieste per più istanze vengono inviate in parallelo. Ad esempio, esegui su ogni istanza uno script diagnostico per istanza già distribuito:

az webapp exec --resource-group <resource-group-name> --name <app-name> --mode execute --command "python3 /home/site/wwwroot/scripts/diagnostics.py" --instance all

Lo script deve acquisire i propri risultati. Utilizzare percorsi di output distinti per istanza e per esecuzione se lo storage è condiviso. Non usare all per migrazioni di database condivisi o altre operazioni che devono essere eseguite solo una volta. Se alcune submission falliscono, la CLI segnala un errore anche se altre istanze potrebbero aver accettato il comando.

Aggiungi --slot <slot-name> per eseguire contro uno slot di deployment.

Limitations

• La modalità esecuzione prende di mira solo il contenitore principale dell'app. Puoi usarlo --target kudu solo in modalità shell interattiva.
• Usa --working-directory o --cwd solo in modalità esecuzione, e fornisci un percorso assoluto.
• Fornire un percorso assoluto per --shell. In modalità esecuzione, puoi usarlo solo con --shell-command.
• Questa anteprima non offre trasferimento file, port forwarding o opzione per selezionare contenitori sidecar arbitrari. Usa metodi di deployment supportati per caricare i file.
• L'esecuzione in background non è uno scheduler di job persistente. Un riavvio o una sostituzione del container può interrompere il lavoro. Non dare per scontati tentativi automatici o un'esecuzione esattamente una volta.