Esercitazione: Distribuire un'app Web Quarkus in Servizio app di Azure e PostgreSQL

in questa esercitazione si distribuisce un'applicazione web quarkus basata sui dati per Servizio app di azure con il servizio di database relazionale database di azure per postgresql. Servizio app di Azure supporta Java edizione Standard (Java SE) in un ambiente server Windows o Linux.

Screenshot dell'applicazione Quarkus che archivia i dati in PostgreSQL.

In questa esercitazione si apprenderà come:

  • Creare un'architettura sicura per impostazione predefinita per Servizio app di Azure e server flessibile di Database di Azure per PostgreSQL.
  • Proteggere i segreti di connessione usando un'identità gestita e il riferimento a Key Vault.
  • Distribuire un'app Quarkus di esempio nel Servizio app da un repository GitHub.
  • Accedere alle impostazioni dell'applicazione App Service nel codice dell'applicazione.
  • Apportare aggiornamenti e ridistribuire il codice dell'applicazione.
  • Generare lo schema del database eseguendo le migrazioni del database.
  • Eseguire lo streaming dei log di diagnostica in Azure.
  • Gestire l'app nel portale di Azure.
  • Effettuare il provisioning della stessa architettura ed effettuare l'implementazione usando Azure Developer CLI.
  • Ottimizzare il flusso di lavoro di sviluppo con GitHub Codespaces e GitHub Copilot.

Prerequisiti

Passare alla fine

Se si vuole solo visualizzare l'app di esempio in questa esercitazione in esecuzione in Azure, eseguire i comandi seguenti in Azure Cloud Shell e seguire il prompt:

mkdir msdocs-quarkus-postgresql-sample-app
cd msdocs-quarkus-postgresql-sample-app
azd init --template msdocs-quarkus-postgresql-sample-app
azd up

1. Eseguire l'esempio

Prima di tutto, configurare un'app guidata dai dati di esempio come punto di partenza. Per praticità, il repository di esempio Hibernate ORM con Panache e RESTEasy include una configurazione contenitore di sviluppo. Il contenitore di sviluppo include tutti gli elementi necessari per sviluppare un'applicazione, tra cui il database, la cache e tutte le variabili di ambiente necessarie per l'applicazione di esempio. Il contenitore di sviluppo può essere eseguito in un codespace GitHub, il che significa che è possibile eseguire l'esempio in qualsiasi computer con un Web browser.

Passaggio 1: in una nuova finestra del browser:

  1. Accedi all'account GitHub.
  2. Accedere a https://github.com/Azure-Samples/msdocs-quarkus-postgresql-sample-app/fork.
  3. Deselezionare Copia solo il ramo principale. Si desiderano tutti i rami.
  4. Selezionare Crea fork.

Screenshot che mostra come creare un fork del repository GitHub di esempio.

Passaggio 2: Nel fork di GitHub:

  1. Selezionare main>starter-no-infra per il ramo starter. Questo ramo contiene solo il progetto di esempio e nessun file o configurazione correlati ad Azure.
  2. Seleziona Codice>Crea uno spazio di codice su starter-no-infra. La configurazione del codespace richiede alcuni minuti.

Screenshot che mostra come creare un codespace in GitHub.

Passaggio 3: nel terminale codespace:

  1. Eseguire mvn quarkus:dev.
  2. Ignorare la notifica Your application running on port 5005 is available.
  3. Quando viene visualizzata la notifica Your application running on port 8080 is available., selezionare Apri nel browser. L'applicazione di esempio dovrebbe essere visualizzata in una nuova scheda del browser. Per arrestare il server di sviluppo Quarkus, digitare Ctrl+C.

Screenshot che mostra come eseguire l'applicazione di esempio all'interno del codespace GitHub.

Per altre informazioni sulla creazione dell'applicazione di esempio Quarkus, vedere la documentazione di Quarkus ORM Hibernate semplificato con Panache e Configurare le origini dati in Quarkus.

Suggerimento

Puoi chiedere a GitHub Copilot informazioni su questo repository. Ad esempio:

  • @workspace Cosa fa questo progetto?
  • @workspace Cosa fa la cartella .devcontainer?

Problemi? Controllare la sezione Risoluzione dei problemi.

2. Creare il Servizio app e PostgreSQL

In questo passaggio si creano le risorse di Azure. Per impostazione predefinita la procedura usata in questa esercitazione crea un set di risorse sicure che include Servizio app e Database di Azure per PostgreSQL. Per il processo di creazione, devi specificare:

  • Nome dell'app Web. Viene usato come parte del nome DNS per l'app sotto forma di https://<app-name>-<hash>.<region>.azurewebsites.net.
  • L'area in cui eseguire l'app fisicamente nel mondo. Viene usato anche come parte del nome DNS per l'app.
  • Stack di runtime per l'app. È qui che si seleziona la versione Java da usare per l'app.
  • Piano di hosting per l'app. Si tratta del piano tariffario che include il set di funzionalità e la capacità di ridimensionamento per l'app.
  • Gruppo di risorse per l'app. Un gruppo di risorse consente di raggruppare (in un contenitore logico) tutte le risorse di Azure necessarie per l'applicazione.

Per creare risorse del Servizio app di Azure, accedere al portale di Azure e seguire questa procedura.

Passaggio 1: nel portale di Azure:

  1. Nella barra di ricerca superiore digitare app service.
  2. Selezionare l'elemento etichettato servizio app sotto l'intestazione Servizi.
  3. Selezionare Crea>App Web. È anche possibile passare direttamente alla creazione guidata.

Screenshot che mostra come usare la casella di ricerca nella barra degli strumenti superiore per trovare la creazione guidata dell'app Web.

Passaggio 2: Configurare la nuova app Compilare il modulo come indicato di seguito.

  1. Nome: msdocs-quarkus-postgres. Viene generato automaticamente un gruppo di risorse denominato msdocs-snapshotus-postgres_group.
  2. Stack di runtime: Java 21.
  3. Stack di server Web Java: Java SE (Server Web incorporato).
  4. Sistema operativo: Linux.
  5. Area: qualunque area di Azure nelle vicinanze.
  6. Piano Linux: Creare nuovo e usare il nome msdocs-quarkus-postgres.
  7. Piano tariffario: Basic B1. Quando si è pronti, è possibile passare a un piano tariffario diverso.

Screenshot che mostra la procedura guidata app Web con la scheda Informazioni di base.

Passaggio 3: Aggiungere un database

  1. Selezionare la scheda Database .
  2. Selezionare Crea un database.
  3. In Motore selezionare PostgreSQL - Server flessibile. Il nome del server e il nome del database vengono impostati per impostazione predefinita sui valori appropriati.

Screenshot che mostra la procedura guidata app Web con la scheda Database.

Passaggio 4: Configurare la distribuzione di GitHub

  1. Selezionare la scheda Distribuzione .
  2. Selezionare Distribuzione continua.
  3. se è la prima volta che si configura la distribuzione di github nel Servizio app, selezionare autorizza ed eseguire l'autenticazione con l'account github.
  4. In Organizzazione selezionare l'alias GitHub.
  5. In Repository selezionare msdocs-quarkus-postgresql-sample-app.
  6. In Ramo, selezionare starter-no-infra.
  7. Selezionare Rivedi e crea.
  8. Al termine della convalida selezionare Crea. Per impostazione predefinita, la creazione guidata crea un'identità assegnata dall'utente per il flusso di lavoro per l'autenticazione tramite Microsoft Entra (autenticazione OIDC). Per le opzioni di autenticazione alternative, vedere Come distribuire su App Service usando GitHub Actions.

Screenshot che mostra la procedura guidata app Web con la scheda Distribuzione.

Passaggio 3: il completamento della distribuzione richiede alcuni minuti. Al termine della distribuzione, selezionare il pulsante Vai alla risorsa. Si viene direttamente indirizzati all'app del servizio app, ma vengono create le risorse seguenti:

  • Gruppo di risorse: contenitore per tutte le risorse create.
  • Piano di servizio app: definisce le risorse di calcolo per il servizio app. Viene creato un piano Linux nel livello Basic.
  • Servizio app: rappresenta l'app ed è in esecuzione nel piano di servizio app.
  • Rete virtuale: integrata con l'app del servizio app, isola il traffico di rete back-end.
  • Server flessibile di Database di Azure per PostgreSQL: accessibile solo dall'interno della rete virtuale. Vengono automaticamente creati un database e un utente nel server.
  • Zone DNS private: Abilita la risoluzione DNS dell'archivio chiavi e del server di database nella rete virtuale.

Screenshot che mostra il processo di distribuzione completato.

3. Proteggere i segreti di connessione

La procedura guidata di creazione ha già generato le variabili di connettività cosiccome le impostazioni dell'app. Tuttavia, le procedure consigliate in materia di sicurezza prevedono di tenere i segreti completamente al di fuori del Servizio app. Sposterai i tuoi segreti in un Key Vault e cambierai l'impostazione dell'app in riferimenti Key Vault con l'aiuto dei Connettori di Servizi.

Passaggio 1: Recuperare la stringa di connessione esistente

  1. Nel menu a sinistra della pagina Servizio app selezionare Impostazioni Variabili > di ambiente.
  2. Selezionare Stringhe di connessione.
  3. Selezionare AZURE_POSTGRESQL_CONNECTIONSTRING.
  4. In Aggiungi/Modifica impostazione applicazione, nel campo Valore, trovare la sezione ID utente= e Password= alla fine della stringa.
  5. Copiare le stringhe di nome utente e password dopo ID utente= e Password= per usarle in un secondo momento. Questa impostazione dell'app consente di connettersi al database Postgres protetto dietro un endpoint privato. Tuttavia, il segreto viene salvato direttamente nell'app del servizio app, che non è la cosa migliore. Cambierai questo.

Screenshot che mostra come visualizzare il valore di un'impostazione dell'app nel Servizio app.

passaggio 2: creare una subnet per la protezione di key vault la rete virtuale ha già due subnet esistenti, ma una è già delegata al Servizio app e l'altra è già delegata a database di azure per postgresql. È possibile crearne un altro per l'accesso sicuro a Key Vault con un endpoint privato. Per altre informazioni, vedere Sicurezza di rete per Azure Key Vault.

  1. Nel menu a sinistra della pagina Servizio app selezionare la scheda Panoramica.
  2. Selezionare il gruppo di risorse dell'app.
  3. Selezionare la rete virtuale nel gruppo di risorse.
  4. Nel menu a sinistra della rete virtuale selezionare Impostazioni >Subnet.
  5. Selezionare + Subnet.
  6. In Nome digitare subnet-keyvault. Accettare i valori predefiniti.
  7. Seleziona Aggiungi.

Screenshot che mostra come creare una subnet nella rete virtuale.

Passaggio 3: Creare un insieme di credenziali delle chiavi per la gestione sicura dei segreti

  1. Nella barra di ricerca superiore digitare "Key Vault", quindi selezionare Marketplace>Key Vault.
  2. In Gruppo di risorse selezionare msdocs-quarkus-postgres_group.
  3. In Nome del Key Vault, digitare un nome composto solo da lettere e numeri.
  4. In Area impostarlo sulla stessa posizione del gruppo di risorse.

Screenshot che mostra come creare un Key Vault.

Passaggio 4: Proteggere l'insieme di credenziali delle chiavi con un endpoint privato

  1. Selezionare la scheda Rete.
  2. Deselezionare Abilita l'accesso pubblico.
  3. Selezionare Creare un endpoint privato.
  4. In Gruppo di risorse selezionare msdocs-quarkus-postgres_group.
  5. Nella finestra di dialogo, in Località, selezionare la stessa località dell'app di App Service.
  6. In Nome digitare msdocs-quarkus-postgresVaultEndpoint.
  7. In Rete virtuale selezionare vnet-xxxxxxx.
  8. In Subnet, subnet-keyvault.
  9. Seleziona OK.
  10. Selezionare Rivedi e crea e quindi Crea. Attendere il completamento della distribuzione dell'insieme di credenziali delle chiavi. Verrà visualizzato il messaggio "La distribuzione è stata completata".

Screenshot che mostra come proteggere un Key Vault con un endpoint privato.

Passaggio 5: Creare un connettore PostgreSQL

  1. nella barra di ricerca superiore digitare msdocs-quarkus-postgres, quindi selezionare la risorsa del Servizio app denominata msdocs-quarkus-postgres.
  2. nel menu a sinistra della pagina Servizio app selezionare impostazioni > connettore di servizi> crea.
  3. In Tipo di servizio selezionare DB per il server flessibile PostgreSQL.
  4. Nel server flessibile PostgreSQL è necessario selezionare già msdocs-quarkus-postgres-server.
  5. Nel database PostgreSQL selezionare msdocs-quarkus-postgres-database.
  6. In Tipo di client selezionare Java.

Screenshot che mostra come creare un connettore PostgreSQL nel Servizio app.

Passaggio 6: Salvare i segreti nell'insieme di credenziali delle chiavi

  1. Seleziona la scheda Autenticazione.
  2. Selezionare Stringa di connessione.
  3. In Nome utente e Password incollare la password copiata in precedenza.
  4. Selezionare Memorizza il segreto in Key Vault.
  5. In Connessione a Key Vault selezionare Crea nuovo. Viene aperta una finestra di dialogo Crea connessione nella parte superiore della finestra di dialogo di modifica.

Una schermata che mostra come modificare un connettore di servizio con una connessione a Key Vault.

Passaggio 7: Stabilire la connessione a Key Vault

  1. Nella finestra di dialogo Crea connessione per Key Vault, in Key Vault, selezionare il Key Vault creato in precedenza.
  2. In Tipo di client selezionare Java per coerenza. Il codice dell'applicazione non usa effettivamente direttamente l'insieme di credenziali delle chiavi.
  3. Selezionare Verifica e crea.
  4. Al termine della convalida selezionare Crea.

Screenshot che mostra come configurare un connettore del servizio Key Vault.

Passaggio 8: Finalizzare le impostazioni del connettore PostgreSQL

  1. Si torna alla finestra di dialogo di modifica per il connettore PostgreSQL. Nella scheda Autenticazione attendere la creazione del connettore del Key Vault. Al termine, l'elenco a discesa Connessione a Key Vault lo seleziona automaticamente.
  2. Selezionare Verifica e crea.
  3. Al termine della convalida selezionare Crea. Attendere che venga visualizzata la notifica Creazione completata.

Screenshot che mostra la connessione dell'insieme di credenziali delle chiavi selezionata nel connettore PostgreSQL.

Passaggio 9: Verificare l'integrazione di Key Vault

  1. Nel menu a sinistra, selezionare nuovamente Impostazioni > Variabili di ambiente.
  2. Accanto a AZURE_POSTGRESQL_CONNECTIONSTRING, selezionare Mostra valore. Il valore deve essere @Microsoft.KeyVault(...), il che significa che si tratta di un riferimento al Key Vault perché il segreto è ora gestito nel Key Vault.

Screenshot che mostra come visualizzare il valore di un'impostazione dell'app che include un riferimento a Key Vault.

passaggio 10: eliminare le credenziali del database dal Servizio app

  1. Selezionare la scheda Stringhe di connessione.
  2. A destra di AZURE_POSTGRESQL_CONNECTIONSTRING selezionare Elimina. Tenere presente che la creazione guidata ha creato automaticamente questa stringa di connessione all'inizio.

Screenshot che mostra come eliminare una stringa di connessione nel Servizio app.

Per riepilogare, il processo per proteggere i segreti di connessione coinvolti:

  • Recupero dei segreti di connessione dalle variabili di ambiente dell'app App Service.
  • Creazione di un insieme di credenziali delle chiavi con un endpoint privato.
  • Creazione di una connessione di Key Vault con l'identità gestita assegnata dal sistema.
  • Creare un connettore di servizio per archiviare i segreti di connessione nell'insieme di credenziali delle chiavi.
  • Eliminare i segreti di connessione precedenti dall'app del Servizio app.

Problemi? Controllare la sezione Risoluzione dei problemi.

4. Distribuire il codice di esempio

Nella creazione guidata è già stata configurata la distribuzione continua dal repository GitHub di esempio usando GitHub Actions. È solo uno dei molti modi per eseguire la distribuzione nel servizio app, ma anche un ottimo modo per avere l'integrazione continua nel processo di distribuzione. Per impostazione predefinita, ogni git push nel repository GitHub avvia l'azione di compilazione e distribuzione.

Tenere presente quanto segue:

  • La porta 8080 è in ascolto sulla porta 8080 per impostazione predefinita. nell'ambiente di produzione, deve essere configurato per restare in ascolto della porta specificata dalla variabile di ambiente PORT nel Servizio app.
  • Il pacchetto Java distribuito deve essere un Uber-Jar.
  • Per semplicità dell'esercitazione, si disabilitano i test durante il processo di distribuzione. Gli strumenti di esecuzione di GitHub Actions non hanno accesso al database PostgreSQL in Azure, quindi tutti i test di integrazione che richiedono l'accesso al database avranno esito negativo, ad esempio nel caso dell'applicazione di esempio Quarkus.

Passaggio 1: Tornare allo spazio di codice GitHub del fork di esempio, eseguire git pull origin starter-no-infra. Viene eseguito il pull del file del flusso di lavoro GitHub di cui è stato eseguito il commit nel codespace.

Screenshot che mostra il pull git all'interno di un codespace GitHub.

Passaggio 2 (opzione 1: con GitHub Copilot):

  1. Avviare una nuova sessione di chat selezionando la visualizzazione Chat e quindi selezionando +.
  2. Chiedere "@workspace Come si connette l'app al database?" Copilot potrebbe fornire una spiegazione del modo in cui vengono configurate le impostazioni dell'origine dati Quarkus in src/main/resources/application.properties.
  3. ad esempio, "@workspace ho creato un connettore del servizio postgresql in Servizio app di azure usando il tipo di client java e il nome dell'impostazione dell'app è azure_postgresql_connectionstring. voglio usare questa stringa di connessione quando l'app è in esecuzione nell'ambiente di produzione." copilot potrebbe fornire un suggerimento di codice simile a quello nell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file src/main/resources/application.properties.
  4. Aprire src/main/resources/application.properties in explorer e aggiungere il suggerimento per il codice.
  5. Pronunciare "@workspace Come configurare questo progetto per creare un file Uber Jar?" Copilot potrebbe fornire un suggerimento di codice simile a quello nell'Opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file src/main/resources/application.properties.
  6. Aprire src/main/resources/application.properties in explorer e aggiungere il suggerimento per il codice.
  7. pronunciare "@workspace come utilizzare la porta del Servizio app?" Copilot potrebbe fornire un suggerimento di codice simile a quello nell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file src/main/resources/application.properties.
  8. Aprire src/main/resources/application.properties in explorer e aggiungere il suggerimento per il codice. GitHub Copilot non fornisce la stessa risposta ogni volta e non è sempre corretta. Potrebbe essere necessario porre altre domande per ottimizzare la risposta. Per suggerimenti, vedere Cosa posso fare con GitHub Copilot nel mio spazio di codice?.

Screenshot che mostra come porre una domanda in una nuova sessione di chat di GitHub Copilot.

Passaggio 2 (opzione 2: senza GitHub Copilot):

  1. Aprire src/main/resources/application.properties in Esplora risorse. Quarkus usa questo file per caricare le proprietà Java.
  2. Rimuovere il commento delle righe da 10 a 12. Queste impostazioni usano l'impostazione dell'app creata con il connettore PostgreSQL, crea un file Jar Uber e imposta la porta su quella usata dal Servizio app.

Screenshot che mostra uno spazio di codice GitHub e il file application.properties aperto.

Passaggio 3 (opzione 1: con GitHub Copilot):

  1. Chiedere "@workspace Per la distribuzione GitHub Actions, si vogliono ignorare i test per evitare errori correlati al database." Copilot potrebbe fornire un suggerimento di codice simile a quello nell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file github/workflows/starter-no-infra_msdocs-quarkus-postgres.yml.
  2. Aprire .github/workflows/starter-no-infra_msdocs-quarkus-postgres.yml in explorer e aggiungere il suggerimento per il codice. Per suggerimenti, vedere Cosa posso fare con GitHub Copilot nel mio spazio di codice?.

Screenshot che mostra come porre una domanda sulla distribuzione di GitHub Actions in una nuova sessione di chat di GitHub Copilot.

Passaggio 3 (opzione 2: senza GitHub Copilot):

  1. Aprire .github/workflows/starter-no-infra_msdocs-quarkus-postgres.yml in explorer. Si tratta del flusso di lavoro di GitHub Actions creato automaticamente dalla creazione guidata.
  2. Trovare il passaggio Build with Maven e modificare il comando run in mvn clean install -DskipTests. -DskipTests indica a Maven di ignorare i test in modo che la distribuzione non fallisca in caso di errori del database. Il contenitore GitHub Actions non può connettersi a un server PostgreSQL.

Screenshot che mostra uno spazio di codice GitHub e un file del flusso di lavoro GitHub aperto.

Passaggio 4:

  1. Selezionare l'estensione Controllo del codice sorgente.
  2. Nella casella di testo digitare un messaggio di commit come Configure DB and deployment. In alternativa, selezionare e lasciare che GitHub Copilot generi automaticamente un messaggio di commit.
  3. Selezionare Commit e quindi confermare con Sì.
  4. Selezionare Sincronizza modifiche 1, quindi confermare con OK.

Screenshot che mostra le modifiche di cui è stato eseguito il commit e il push in GitHub.

Passaggio 5:

  1. Nel menu a sinistra selezionare Distribuzione>Centro distribuzione>Logs.
  2. Nell'elemento di log per l'esecuzione della distribuzione selezionare la voce Compila/Distribuisci Log con il timestamp più recente.

Screenshot che mostra come aprire i log di distribuzione nel Centro distribuzione.

Passaggio 6: si passa al repository GitHub e si nota che l'azione GitHub è in esecuzione. Il file del flusso di lavoro definisce due fasi separate, compilare e distribuire. Attendere che l'esecuzione di GitHub mostri lo stato Operazione riuscita. Ci vogliono circa 5 minuti.

Screenshot che mostra un'esecuzione di GitHub in corso.

Problemi? Controllare la sezione Risoluzione dei problemi.

5. Passare all'app

Passaggio 1: Nella pagina Servizio app:

  1. Nel menu a sinistra selezionare Panoramica.
  2. Selezionare l'URL dell'app.

Screenshot che mostra come avviare un servizio app dal portale di Azure.

Passaggio 2: aggiungere alcuni frutti all'elenco. A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.

Screenshot dell'app Web Quarkus con PostgreSQL in esecuzione in Azure che mostra un elenco di frutti.

6. Eseguire lo streaming dei log di diagnostica

Il Servizio app di Azure acquisisce tutto l'output dei messaggi nella console per facilitare la diagnosi dei problemi con l'applicazione. L'applicazione di esempio include istruzioni di registrazione JBoss standard per illustrare questa funzionalità, come illustrato di seguito.

private static final Logger LOGGER = Logger.getLogger(FruitEntityResource.class.getName());

@GET
public List<FruitEntity> get() {
    LOGGER.info("In FruitEntityResource.get()");
    return FruitEntity.listAll(Sort.by("name"));
}

Passaggio 1: Nella pagina Servizio app:

  1. Nel menu a sinistra selezionare Monitoraggio>Log di servizio app.
  2. In Registrazione applicazione selezionare File System.
  3. Nel menu in alto, selezionare Salva.

Screenshot che mostra come abilitare i log nativi nel servizio app nel portale di Azure.

Passaggio 2: dal menu a sinistra selezionare Flusso di log. Vengono visualizzati i log per l'app, inclusi i log e i log della piattaforma dall'interno del contenitore.

Screenshot che mostra come visualizzare il flusso di log nel portale di Azure.

Per altre informazioni sulla registrazione nelle app Java, vedere la serie Abilitare OpenTelemetry di Monitoraggio di Azure per .NET, Node.js, Python e Applicazioni Java.

7. Pulire le risorse

Al termine, è possibile eliminare tutte le risorse dalla sottoscrizione di Azure eliminando il gruppo di risorse.

Passaggio 1: nella barra di ricerca nella parte superiore del portale di Azure:

  1. Immettere il nome del gruppo di risorse.
  2. Selezionare il gruppo di risorse.

Screenshot che illustra come cercare e passare a un gruppo di risorse nel portale di Azure.

Passaggio 2: nella pagina del gruppo di risorse selezionare Elimina gruppo di risorse.

Screenshot che mostra la posizione del pulsante Elimina gruppo di risorse nel portale di Azure.

Passaggio 3:

  1. Immettere il nome del gruppo di risorse per confermare l'eliminazione.
  2. Selezionare Elimina.
  3. Confermare nuovamente con Elimina.

Screenshot della finestra di dialogo di conferma per l’eliminazione di un gruppo di risorse nel portale di Azure. :

2. Creare risorse di Azure e distribuire un'app di esempio

In questo passaggio si creano le risorse di Azure e si distribuisce un'app di esempio nel servizio app in Linux. Per impostazione predefinita la procedura usata in questa esercitazione crea un set di risorse sicure che include Servizio app e Database di Azure per PostgreSQL.

Il contenitore di sviluppo ha già l'interfaccia della Azure Developer CLI (AZD).

  1. Dalla radice del repository del codespace GitHub eseguire azd init.

    azd init --template javase-app-service-postgresql-infra

  2. Quando richiesto, fornire le risposte seguenti:

    Domanda Risposta
    La cartella attuale non è vuota. Vorresti inizializzare un progetto qui in "<your-directory>"? S
    Cosa si vuole fare con questi file? Mantenere invariati i file esistenti
    Immettere un nuovo nome di ambiente Digitare un nome univoco. Il modello AZD usa questo nome come parte del nome DNS dell'app Web in Azure (<app-name>-<hash>.azurewebsites.net). Sono consentiti caratteri alfanumerici e trattini.

  3. Accedere ad Azure eseguendo il comando azd auth login e seguendo il prompt:

    azd auth login

  4. Creare le risorse di Azure necessarie con il azd provision comando . Seguire la richiesta di selezionare la sottoscrizione e il percorso desiderati per le risorse di Azure.

    azd provision

    Il completamento del comando azd provision richiede circa 15 minuti (la cache Redis richiede il tempo maggiore). Successivamente, modificherai il codice in modo che funzioni con Servizio App e distribuirai le modifiche con azd deploy. Durante l'esecuzione, il comando fornisce messaggi sul processo di provisioning e distribuzione, incluso un collegamento alla distribuzione in Azure.

    Questo modello AZD contiene file (azure.yaml e la directory infra ) che generano un'architettura sicura per impostazione predefinita con le risorse di Azure seguenti:

    • Gruppo di risorse: contenitore per tutte le risorse create.
    • Piano di servizio app: definisce le risorse di calcolo per il servizio app. Viene creato un piano Linux nel livello Basic.
    • Servizio app: rappresenta l'app ed è in esecuzione nel piano di servizio app.
    • Rete virtuale: integrata con l'app del servizio app, isola il traffico di rete back-end.
    • Endpoint privati: accedere agli endpoint per l’insieme di credenziali delle chiavi e la cache Redis nella rete virtuale.
    • Interfacce di rete: rappresenta gli indirizzi IP privati, uno per ognuno degli endpoint privati.
    • Server flessibile di Database di Azure per PostgreSQL: accessibile solo dall'interno della rete virtuale. Vengono automaticamente creati un database e un utente nel server.
    • Zona DNS privato: abilita la risoluzione DNS del server PostgreSQL nella rete virtuale.
    • Area di lavoro Log Analytics: funge da contenitore di destinazione per l'app che spedisce i log e permette anche di eseguire query sui log.
    • Cache Redis di Azure: accessibile solo da dietro l'endpoint privato.
    • Insieme di credenziali delle chiavi: accessibile solo da dietro l'endpoint privato. Usato per gestire i segreti per l'app di App Service.

  5. Al termine del provisioning, trovare l'impostazione AZURE_POSTGRESQL_CONNECTIONSTRING nell'output AZD. Per proteggere i segreti, vengono visualizzati solo i nomi delle impostazioni. L'output AZD è simile al seguente:

     App Service app has the following connection settings:
         - AZURE_POSTGRESQL_CONNECTIONSTRING
         - AZURE_REDIS_CONNECTIONSTRING
         - AZURE_KEYVAULT_RESOURCEENDPOINT
         - AZURE_KEYVAULT_SCOPE

    Il modello AZD usato ha generato le variabili di connettività già come impostazioni dell'app e li restituisce al terminale per praticità. Le impostazioni dell'app sono un modo per mantenere i segreti di connessione all'esterno del repository di codice. È anche possibile trovare il collegamento diretto alla pagina delle impostazioni dell'app per l'app del Servizio app creata.

Problemi? Controllare la sezione Risoluzione dei problemi.

3. Modificare il codice di esempio e ridistribuire

È necessario apportare alcune modifiche al codice dell'applicazione per renderlo compatibile con il Servizio app:

  • La porta 8080 è in ascolto sulla porta 8080 per impostazione predefinita. nell'ambiente di produzione, deve essere configurato per restare in ascolto della porta specificata dalla variabile di ambiente PORT nel Servizio app.
  • Il pacchetto Java distribuito deve essere un Uber-Jar.
  • Per semplicità dell'esercitazione, si disabilitano i test durante il processo di distribuzione. Gli strumenti di esecuzione di GitHub Actions non hanno accesso al database PostgreSQL in Azure, quindi tutti i test di integrazione che richiedono l'accesso al database avranno esito negativo, ad esempio nel caso dell'applicazione di esempio Quarkus.

  1. Nello spazio di codice GitHub avviare una nuova sessione di chat selezionando la visualizzazione Chat e quindi selezionando +.

  2. Chiedere "@workspace Come si connette l'app al database?" Copilot potrebbe fornire una spiegazione del modo in cui vengono configurate le impostazioni dell'origine dati quarkus in src/main/resources/application.properties.

  3. ad esempio, "@workspace ho creato un connettore del servizio postgresql in Servizio app di azure usando il tipo di client java e il nome dell'impostazione dell'app è azure_postgresql_connectionstring. voglio usare questa stringa di connessione quando l'app è in esecuzione nell'ambiente di produzione." Copilot potrebbe fornire un suggerimento di codice simile a quello nell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file src/main/resources/application.properties.

  4. Aggiungere il suggerimento per il codice in src/main/resources/application.properties.

  5. Pronunciare "@workspace Come configurare questo progetto per creare un file Uber Jar?" Copilot potrebbe fornire un suggerimento di codice simile a quello nell'Opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file src/main/resources/application.properties.

  6. Aggiungere il suggerimento per il codice in src/main/resources/application.properties.

  7. pronunciare "@workspace come utilizzare la porta del Servizio app?" Copilot potrebbe fornire un suggerimento di codice simile a quello nell'opzione 2: senza i passaggi di GitHub Copilot riportati di seguito e persino indicare di apportare la modifica nel file src/main/resources/application.properties.

  8. Aggiungere il suggerimento per il codice in src/main/resources/application.properties.

    GitHub Copilot non fornisce la stessa risposta ogni volta e non è sempre corretta. Potrebbe essere necessario porre altre domande per ottimizzare la risposta. Per suggerimenti, vedere Cosa posso fare con GitHub Copilot nel mio spazio di codice?.

  9. Nel terminale eseguire azd deploy.

    azd deploy

Problemi? Controllare la sezione Risoluzione dei problemi.

5. Passare all'app

  1. Nell'output AZD trovare l'URL dell'app e passarvi nel browser. L'URL è simile al seguente nell'output AZD:

     Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: https://<app-name>.azurewebsites.net/

  2. Aggiungere alcuni frutti all'elenco.

    Screenshot dell'app Web Quarkus con PostgreSQL in esecuzione in Azure che mostra un elenco di frutti.

    A questo punto un'app Web è in esecuzione nel servizio app di Azure, con connettività sicura a Database di Azure per PostgreSQL.

Problemi? Controllare la sezione Risoluzione dei problemi.

6. Eseguire lo streaming dei log di diagnostica

Il servizio app di Azure può acquisire i log della console per diagnosticare i problemi relativi all'applicazione. Per praticità, il modello AZD consente già di accedere al file system locale e di inviare i log a un'area di lavoro Log Analytics.

L'applicazione di esempio include istruzioni di registrazione JBoss standard per illustrare questa funzionalità, come illustrato di seguito.

private static final Logger LOGGER = Logger.getLogger(FruitEntityResource.class.getName());

@GET
public List<FruitEntity> get() {
    LOGGER.info("In FruitEntityResource.get()");
    return FruitEntity.listAll(Sort.by("name"));
}

Nell'output AZD trovare il collegamento per trasmettere i log del servizio app e passarvi nel browser. Il collegamento è simile al seguente nell'output AZD:

Stream App Service logs at: https://portal.azure.com/#@/resource/subscriptions/<subscription-guid>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name>/logStream

Per altre informazioni sulla registrazione nelle app Java, vedere la serie Abilitare OpenTelemetry di Monitoraggio di Azure per .NET, Node.js, Python e Applicazioni Java.

Problemi? Controllare la sezione Risoluzione dei problemi.

7. Pulire le risorse

Per eliminare tutte le risorse di Azure nell'ambiente di distribuzione corrente, eseguire azd down e seguire le istruzioni.

azd down

Risoluzione dei problemi

L'esecuzione di GitHub Actions non è riuscita nella fase di compilazione

Selezionare la fase di compilazione non riuscita per vedere quale passaggio non è riuscito. Se si tratta della fase Compila con Maven, espandere il passaggio per verificare che venga usata l'opzione -DskipTests. In alternativa, tornare a 4. Distribuire il codice di esempio e modificare il file del flusso di lavoro di GitHub in base alle istruzioni.

Impossibile avviare l'app e visualizzare l'errore seguente nel flusso di log: "Le classi modello sono definite per l'unità di persistenza <predefinita>, ma l'origine dati configurata <predefinita> non è stata trovata: l'entità EntityManagerFactory predefinita non verrà creata".

Questo errore Quarkus è molto probabile perché l'app non riesce a connettersi al database di Azure. Assicurarsi che l'impostazione dell'app AZURE_POSTGRESQL_CONNECTIONSTRING non sia stata modificata e che application.properties usi correttamente l'impostazione dell'app.

L'app non è stata avviata e il flusso di log mostra "In attesa della risposta alla richiesta di riscaldamento per il contenitore"

l'applicazione probabilmente non è configurata per l'ascolto della porta specificata dalla variabile di ambiente PORT del Servizio app, quindi non può rispondere ad alcuna richiesta. Se il Servizio app non riceve una risposta dall'applicazione, presuppone che l'applicazione non sia stata avviata. Tornare a 4. Distribuire il codice di esempio e verificare che application.properties sia configurato correttamente.

L'app funziona ma viene visualizzato il log degli errori "ERROR [org.acm.hib.orm.pan.ent.FruitEntityResource] (vert.x-eventloop-thread-0) Failed to handle request: jakarta.ws.rs.NotFoundException: HTTP 404 Not Found".

Si tratta di un errore Vert.x (vedere Architettura Quarkus Reactive), che indica che il client ha richiesto un percorso sconosciuto. Può verificarsi la prima volta che l'app viene avviata, quando il client richiede l'API REST prima che si verifichi la migrazione del database in stato di ibernazione.

nel Servizio app questo errore si verifica anche in ogni avvio dell'app perché il Servizio app verifica che l'app inizi inviando una richiesta GET a /robots933456.txt.

Domande frequenti

Quanto costa questa configurazione?

I prezzi per le risorse create sono i seguenti:

  • Il piano di servizio app viene creato nel livello Basic e può essere ridimensionato verso l'alto o verso il basso. Vedere Prezzi del servizio app.
  • Il server flessibile PostgreSQL viene creato nel livello con possibilità di burst più bassa Standard_B1ms, con dimensioni di archiviazione minime, che possono essere ridimensionate, ossia aumentate o ridotte. Vedere i piani tariffari di Database di Azure per PostgreSQL.
  • La rete virtuale non comporta alcun addebito a meno che non si configurino funzionalità aggiuntive, ad esempio il peering. Vedere Prezzi della rete virtuale di Azure.
  • La zona DNS privata comporta un piccolo addebito. Vedere Prezzi di DNS di Azure.

Ricerca per categorie: connettersi al server PostgreSQL protetto dietro la rete virtuale con altri strumenti

  • Per l'accesso di base da uno strumento da riga di comando, è possibile eseguire psql dal terminale SSH dell'app.
  • Per connettersi da uno strumento desktop, il computer deve trovarsi all'interno della rete virtuale. Ad esempio, potrebbe trattarsi di una macchina virtuale di Azure connessa a una delle subnet o di un computer in una rete locale con una connessione VPN da sito a sito con la rete virtuale di Azure.
  • È anche possibile integrare Azure Cloud Shell con la rete virtuale.

Come funziona lo sviluppo di app locali con GitHub Actions?

Usando il file del flusso di lavoro generato automaticamente dal servizio app come esempio, ogni git push avvia una nuova esecuzione di compilazione e distribuzione. Da un clone locale del repository GitHub si effettua il push degli aggiornamenti desiderati in GitHub. Ad esempio:

git add .
git commit -m "<some-message>"
git push origin main

Cosa accade se si vogliono eseguire test con PostgreSQL durante il flusso di lavoro di GitHub?

L'applicazione di esempio Quarkus predefinita include test con connettività del database. Per evitare errori di connessione, è stata aggiunta la proprietà -skipTests. Se si vuole, è possibile eseguire i test su un contenitore del servizio PostgreSQL. Ad esempio, nel file del flusso di lavoro generato automaticamente nel fork di GitHub (.github/workflows/main_cephalin-quarkus.yml), apportare le modifiche seguenti:

  1. Aggiungere il codice YAML per il contenitore PostgreSQL al processo build, come illustrato nel frammento di codice seguente.

    ...
jobs:
  build:
    runs-on: ubuntu-latest

    # BEGIN CODE ADDITION
    container: ubuntu
    services:
      # Hostname for the PostgreSQL container
      postgresdb:
        image: postgres
        env:
          POSTGRES_PASSWORD: postgres
          POSTGRES_USER: postgres
          POSTGRES_DB: postgres
        # Set health checks to wait until postgres has started
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    # END CODE ADDITION

    steps:
      - uses: actions/checkout@v4
      ...

    container: ubuntu indica a GitHub di eseguire il processo di build in un contenitore. In questo modo, la stringa di connessione nell'ambiente di sviluppo jdbc:postgresql://postgresdb:5432/postgres può funzionare così come è quando viene eseguito il flusso di lavoro. Per altre informazioni sulla connettività PostgreSQL in GitHub Actions, vedere Creazione di contenitori del servizio PostgreSQL.

  2. Nel passaggio Build with Maven rimuovere -DskipTests. Ad esempio:

          - name: Build with Maven
        run: mvn clean install -Dquarkus.package.type=uber-jar

Non ho i permessi necessari per creare un'identità assegnata dall'utente

Vedere Configurare la distribuzione di GitHub Actions dal Centro distribuzione.

Cosa è possibile fare con GitHub Copilot nel codespace?

Potresti aver notato che la visualizzazione chat di GitHub Copilot era già presente quando hai creato il codespace. Tuttavia, è necessario un account GitHub Copilot (disponibile una versione di valutazione gratuita di 30 giorni).

Alcuni suggerimenti per l'utente quando si parla con GitHub Copilot:

  • In una singola sessione di chat, le domande e le risposte si basano l'una sull'altra e puoi regolare le tue domande per ottimizzare la risposta che ottieni.
  • Per impostazione predefinita, GitHub Copilot non ha accesso ad alcun file nel repository. Per porre domande su un file, aprire prima il file nell'editor.
  • Per consentire a GitHub Copilot di accedere a tutti i file nel repository quando si preparano le risposte, iniziare la domanda con @workspace. Per altre informazioni, vedere Use the @workspace agent.
  • Nella sessione di chat, GitHub Copilot può suggerire modifiche e indicare tramite @workspace anche dove apportarle, ma non è consentito apportare le modifiche per te. È necessario aggiungere le modifiche suggerite e testarle.

Passaggi successivi

Altre informazioni sull'esecuzione di app Java nel Servizio app sono disponibili nella Guida per gli sviluppatori.

Configurare un'app Java nel servizio app di Azure

Informazioni su come proteggere l'app con un dominio e un certificato personalizzati.

  Proteggere con dominio personalizzato e certificato di protezione

  • Last updated on