Creare un'app Web PHP e MySQL in Azure

Le app Web di Azure forniscono un servizio di hosting Web ad alta scalabilità e con funzioni di auto-correzione. Questa esercitazione illustra come creare un'app Web PHP in Azure e connetterla a un database MySQL. Al termine, sarà disponibile un'app Laravel in esecuzione nelle app Web del servizio app di Azure.

App PHP in esecuzione nel Servizio app di Azure

In questa esercitazione si apprenderà come:

  • Creare un database MySQL in Azure
  • Connettere un'app PHP a MySQL
  • Distribuire l'app in Azure
  • Aggiornare il modello di dati e ridistribuire l'app
  • Eseguire lo streaming dei log di diagnostica in Azure
  • Gestire l'app nel portale di Azure

Prerequisiti

Per completare questa esercitazione:

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Preparare MySQL in locale

In questo passaggio, si crea un database nel server locale di MySQL da usare in questa esercitazione.

Connettersi al server MySQL locale

In una finestra terminale connettersi al server MySQL locale. È possibile usare questa finestra del terminale per eseguire tutti i comandi presenti in questa esercitazione.

mysql -u root -p

Se viene richiesto di immettere una password, immettere la password per l'account root. Se non si ricorda la password dell'account radice, vedere MySQL: procedura per reimpostare la password radice.

Se il comando viene eseguito correttamente, il server MySQL è in esecuzione. In caso contrario, assicurarsi che il server MySQL locale sia stato avviato seguendo la procedura successiva all'installazione di MySQL.

Creare un database in locale

Al prompt mysql creare un database.

CREATE DATABASE sampledb;

Chiudere la connessione al server digitando quit.

quit

Creare un'app PHP in locale

In questo passaggio si ottiene un'applicazione di esempio Laravel, se ne configurare la connessione al database e la si esegue in locale.

Clonare l'esempio

Nella finestra del terminale usare il comando cd per passare a una directory di lavoro.

Eseguire il comando seguente per clonare l'archivio di esempio.

git clone https://github.com/Azure-Samples/laravel-tasks

Eseguire cd nella directory clonata. Installare i pacchetti necessari.

cd laravel-tasks
composer install

Configurare la connessione di MySQL

Nella radice del repository creare un file denominato .env. Copiare le variabili seguenti nel file .env. Sostituire il segnaposto <root_password> con la password dell'utente ROOT MySQL.

APP_ENV=local
APP_DEBUG=true
APP_KEY=SomeRandomString

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_DATABASE=sampledb
DB_USERNAME=root
DB_PASSWORD=<root_password>

Per informazioni su come viene usato il file .env da Laravel, vedere Laravel Environment Configuration (Configurazione dell'ambiente Laravel).

Eseguire l'esempio in locale

Eseguire le migrazioni del database di Laravel per creare le tabelle necessarie all'applicazione. Per visualizzare le tabelle create nelle migrazioni, esaminare la directory database/migrations nel repository Git.

php artisan migrate

Generare una nuova chiave per l'applicazione Laravel.

php artisan key:generate

Eseguire l'applicazione.

php artisan serve

Andare a http://localhost:8000 in un browser. Nella pagina aggiungere alcune attività.

PHP si connette correttamente a MySQL

Per arrestare PHP, digitare Ctrl + C nel terminale.

Avviare Azure Cloud Shell

Azure Cloud Shell è una shell Bash gratuita che può essere eseguita direttamente nel portale di Azure. Include l'interfaccia della riga di comando di Azure preinstallata e configurata per l'uso con l'account. Fare clic sul pulsante Cloud Shell nel menu nel riquadro in alto a destra nel portale di Azure.

Cloud Shell

Il pulsante avvia una shell interattiva che è possibile usare per eseguire tutti i passaggi in questo argomento:

Screenshot che mostra la finestra di Cloud Shell nel portale

Creare MySQL in Azure

In questo passaggio viene creato un database MySQL nel database di Azure per MySQL (anteprima). Successivamente viene configurata l'applicazione PHP per la connessione al database.

Creare un gruppo di risorse

Creare un gruppo di risorse con il comando az group create.

Un gruppo di risorse è un contenitore logico in cui vengono distribuite e gestite risorse di Azure come app Web, database e account di archiviazione.

L'esempio seguente crea un gruppo di risorse denominato myResourceGroup nella località westeurope.

az group create --name myResourceGroup --location westeurope

In genere, il gruppo di risorse e le risorse vengono create in un'area nelle vicinanze. Per visualizzare tutte le località supportate per le app Web di Azure, eseguire il comando az appservice list-locations.

Creare un server MySQL

Creare un server nel database di Azure per MySQL (anteprima) con il comando az mysql server create.

Nel comando seguente sostituire il segnaposto <mysql_server_name> con il nome del server MySQL (i caratteri validi sono a-z, 0-9 e -). Poiché questo nome fa parte del nome host del server MySQL (<mysql_server_name>.database.windows.net) è necessario che sia univoco a livello globale.

az mysql server create \
    --name <mysql_server_name> \
    --resource-group myResourceGroup \
    --location "North Europe" \
    --admin-user adminuser \
    --admin-password MySQLAzure2017

Al termine della creazione del server MySQL, l'interfaccia della riga di comando di Azure mostra informazioni simili all'esempio seguente:

{
  "administratorLogin": "adminuser",
  "administratorLoginPassword": null,
  "fullyQualifiedDomainName": "<mysql_server_name>.database.windows.net",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.DBforMySQL/servers/<mysql_server_name>",
  "location": "northeurope",
  "name": "<mysql_server_name>",
  "resourceGroup": "myResourceGroup",
  ...
}

Configurare il firewall del server

Creare una regola del firewall per il server MySQL per consentire le connessioni client tramite il comando az mysql server firewall-rule create.

az mysql server firewall-rule create \
    --name allIPs \
    --server <mysql_server_name> \
    --resource-group myResourceGroup \
    --start-ip-address 0.0.0.0 \
    --end-ip-address 255.255.255.255
Nota

Database di Azure per MySQL (anteprima) attualmente non limita le connessioni solo ai servizi di Azure. Poiché gli indirizzi IP in Azure sono assegnati dinamicamente, è consigliabile abilitare tutti gli indirizzi IP. Il servizio è disponibile in anteprima. Verranno resi disponibili metodi migliori per la protezione del database.

Connettersi al server MySQL di produzione in locale

Nella finestra terminale connettersi al server MySQL in Azure. Usare il valore specificato in precedenza per <mysql_server_name>.

mysql -u adminuser@<mysql_server_name> -h <mysql_server_name>.database.windows.net -P 3306 -p

Quando viene richiesto di immettere una password, usare $tr0ngPa$w0rd!, la password specificata al momento della creazione del database.

Creare un database di produzione

Al prompt mysql creare un database.

CREATE DATABASE sampledb;

Creare un utente con autorizzazioni

Creare un utente di database denominato phpappuser e assegnare all'utente tutti i privilegi per il database sampledb.

CREATE USER 'phpappuser' IDENTIFIED BY 'MySQLAzure2017'; 
GRANT ALL PRIVILEGES ON sampledb.* TO 'phpappuser';

Chiudere la connessione al server digitando quit.

quit

Connettere l'app a MySQL di Azure

In questo passaggio l'applicazione PHP viene connessa al database MySQL creato in Database di Azure per MySQL (anteprima).

Configurare la connessione al database

Nella radice del repository creare un file .env.production e copiare le variabili seguenti nel file. Sostituire il segnaposto <mysql_server_name>.

APP_ENV=production
APP_DEBUG=true
APP_KEY=SomeRandomString

DB_CONNECTION=mysql
DB_HOST=<mysql_server_name>.database.windows.net
DB_DATABASE=sampledb
DB_USERNAME=phpappuser@<mysql_server_name>
DB_PASSWORD=MySQLAzure2017
MYSQL_SSL=true

Salvare le modifiche.

Suggerimento

Per proteggere le informazioni di connessione MySQL, il file è già escluso dal repository Git (vedere .gitignore nella radice del repository). Successivamente verrà illustrato come configurare le variabili di ambiente nel servizio app per connettere il database in Database di Azure per MySQL (anteprima). Con le variabili di ambiente non è necessario il file .env nel servizio app.

Configurare il certificato SSL

Per impostazione predefinita, Database di Azure per MySQL impone le connessioni SSL dai client. Per connettersi al database MySQL in Azure è necessario usare un certificato SSL .pem.

Aprire config/database.php e aggiungere i parametri sslmode e options a connections.mysql, come illustrato nel codice seguente.

'mysql' => [
    ...
    'sslmode' => env('DB_SSLMODE', 'prefer'),
    'options' => (env('MYSQL_SSL')) ? [
        PDO::MYSQL_ATTR_SSL_KEY    => '/ssl/certificate.pem', 
    ] : []
],

Per informazioni su come generare il file certificate.pem, vedere Configurare la connettività SSL nell'applicazione per la connessione sicura a Database di Azure per MySQL.

Suggerimento

Il percorso /ssl/certificate.pem punta a un file certificate.pem esistente nel repository Git. Il file è già incluso per ragioni di praticità in questa esercitazione. È consigliabile non eseguire il commit dei certificati .pem nel controllo del codice sorgente.

Testare l'applicazione in locale

Eseguire le migrazioni del database di Laravel con .env.production come file dell'ambiente per creare le tabelle nel proprio database MySQL nel database di Azure per MySQL (anteprima). Tenere presente che . env.production include le informazioni di connessione al database MySQL in Azure.

php artisan migrate --env=production --force

.env.production non dispone ancora di una chiave applicazione valida. Generarne una nuova nel terminale.

php artisan key:generate --env=production --force

Eseguire l'applicazione di esempio con .env.production come file dell'ambiente.

php artisan serve --env=production

Accedere a http://localhost:8000. Se la pagina viene caricata senza errori, l'applicazione PHP si connette al database MySQL in Azure.

Nella pagina aggiungere alcune attività.

PHP si connette correttamente al database di Azure per MySQL (anteprima)

Per arrestare PHP, digitare Ctrl + C nel terminale.

Eseguire il commit delle modifiche

Eseguire i comandi Git seguenti per eseguire il commit delle modifiche:

git add .
git commit -m "database.php updates"

L'app è pronta per la distribuzione.

Distribuzione in Azure

In questo passaggio viene distribuita l'applicazione PHP connessa a MySQL nel servizio app di Azure.

Creare un piano di servizio app

Creare un piano di servizio app con il comando az appservice plan create.

Un piano di servizio app specifica la località, le dimensioni e le funzionalità della server farm Web che ospita l'app. Quando si ospitano più app, è possibile limitare i costi configurando le app Web in modo che condividano un singolo piano di servizio app.

I piani di servizio app definiscono:

  • Area (ad esempio Europa settentrionale, Stati Uniti orientali o Asia sud-orientale)
  • Dimensione dell'istanza (Small, Medium o Large)
  • Numero di scala (da 1 a 20 istanze)
  • SKU (Gratuito, Condiviso, Basic, Standard o Premium)

L'esempio seguente crea un piano di servizio app denominato myAppServicePlan nel piano tariffario Gratuito:

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE

Al termine della creazione del piano di servizio app, l'interfaccia della riga di comando di Azure visualizza informazioni simili all'esempio seguente:

{ 
  "adminSiteName": null,
  "appServicePlanName": "myAppServicePlan",
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "app",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

Creare un'app Web

Creare un'app Web nel piano di servizio app myAppServicePlan con il comando az webapp create.

L'app Web fornisce uno spazio host per il codice e un URL per visualizzare l'app distribuita.

Nel comando seguente sostituire <nome_app> con un nome univoco (i caratteri validi sono a-z, 0-9 e -). Se <app_name> non è univoco, verrà visualizzato il messaggio di errore "Il sito Web con il nome specificato esiste già". L'URL predefinito dell'app Web è https://<app_name>.azurewebsites.net.

az webapp create --name <app_name> --resource-group myResourceGroup --plan myAppServicePlan

Al termine della creazione dell'app Web, l'interfaccia della riga di comando di Azure visualizza informazioni simili all'esempio seguente:

{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app_name>.azurewebsites.net",
  "enabled": true,
  "enabledHostNames": [
    "<app_name>.azurewebsites.net",
    "<app_name>.scm.azurewebsites.net"
  ],
  "gatewaySiteName": null,
  "hostNameSslStates": [
    {
      "hostType": "Standard",
      "name": "<app_name>.azurewebsites.net",
      "sslState": "Disabled",
      "thumbprint": null,
      "toUpdate": null,
      "virtualIp": null
    }
    < JSON data removed for brevity. >
}

Passare al sito per visualizzare l'app Web appena creata.

http://<app_name>.azurewebsites.net

Impostare la versione di PHP

Impostare la versione PHP necessaria all'applicazione usando il comando az webapp config set.

Il comando seguente imposta la versione PHP su 7.0.

az webapp config set \
    --name <app_name> \
    --resource-group myResourceGroup \
    --php-version 7.0

Configurare le impostazioni del database

Come evidenziato in precedenza, è possibile connettersi al database MySQL di Azure mediante le variabili di ambiente nel servizio app.

Nel servizio app le variabili di ambiente vengono impostate come impostazioni dell'app usando il comando az webapp config appsettings set.

Il comando seguente configura le impostazioni dell'app DB_HOST, DB_DATABASE, DB_USERNAME e DB_PASSWORD. Sostituire i segnaposto <appname> e <mysql_server_name>.

az webapp config appsettings set \
    --name <app_name> \
    --resource-group myResourceGroup \
    --settings DB_HOST="<mysql_server_name>.database.windows.net" DB_DATABASE="sampledb" DB_USERNAME="phpappuser@<mysql_server_name>" DB_PASSWORD="MySQLAzure2017" MYSQL_SSL="true"

È possibile usare il metodo getenv di PHP per accedere alle impostazioni. Il codice Laravel usa un wrapper env su getenv di PHP. Ad esempio, la configurazione di MySQL in config/database.php è simile al codice seguente:

'mysql' => [
    'driver'    => 'mysql',
    'host'      => env('DB_HOST', 'localhost'),
    'database'  => env('DB_DATABASE', 'forge'),
    'username'  => env('DB_USERNAME', 'forge'),
    'password'  => env('DB_PASSWORD', ''),
    ...
],

Configurare le variabili di ambiente di Laravel

Laravel richiede una chiave di applicazione nel servizio app. È possibile configurarla con le impostazioni dell'app.

Usare php artisan per generare una nuova chiave applicazione senza salvarla in .env.

php artisan key:generate --show

Impostare la chiave dell'applicazione nell'app Web del servizio app usando il comando az webapp config appsettings set. Sostituire i segnaposto <appname> e <outputofphpartisankey:generate>.

az webapp config appsettings set \
    --name <app_name> \
    --resource-group myResourceGroup \
    --settings APP_KEY="<output_of_php_artisan_key:generate>" APP_DEBUG="true"

APP_DEBUG="true" indica a Laravel di restituire le informazioni di debug quando l'app Web distribuita rileva errori. Quando si esegue un'applicazione di produzione, è consigliabile impostarla su false.

Impostare il percorso virtuale dell'applicazione

Impostare il percorso virtuale dell'applicazione per l'app Web. Questo passaggio è necessario perché il ciclo di vita dell'applicazione Laravel ha inizio nella directory public anziché nella directory radice dell'applicazione. Gli altri framework PHP il cui ciclo di vita si avvia nella directory radice funzionano anche senza la configurazione manuale del percorso dell'applicazione virtuale.

Impostare il percorso virtuale dell'applicazione usando il comando az resource update. Sostituire il segnaposto <appname> .

az resource update \
    --name web \
    --resource-group myResourceGroup \
    --namespace Microsoft.Web \
    --resource-type config \
    --parent sites/<app_name> \
    --set properties.virtualApplications[0].physicalPath="site\wwwroot\public" \
    --api-version 2015-06-01

Per impostazione predefinita, il servizio app di Azure fa in modo che il percorso virtuale dell'applicazione radice (/) punti alla directory radice dei file dell'applicazione distribuiti (sites\wwwroot).

Configurare un utente della distribuzione

Creare credenziali di distribuzione con il comando az webapp deployment user set.

Un utente della distribuzione è necessario per la distribuzione con FTP e l'istanza Git locale in un'app Web. Nome utente e password sono a livello di account. Sono quindi diversi dalle credenziali della sottoscrizione di Azure.

Nel comando seguente sostituire <user-name> e <password> con un nuovo nome utente e una nuova password. Il nome utente deve essere univoco. La password deve essere composta da almeno otto caratteri, con due dei tre elementi seguenti: lettere, numeri e simboli.

az webapp deployment user set --user-name <username> --password <password>

Se viene visualizzato un errore 'Conflict'. Details: 409, modificare il nome utente. Se viene visualizzato un errore 'Bad Request'. Details: 400, usare una password più complessa.

L'utente di distribuzione viene creato una sola volta e può essere usato per tutte le distribuzioni di Azure.

Nota

Registrare il nome utente e la password. Saranno necessari per distribuire l'app Web in un secondo momento.

Configurare la distribuzione con l'istanza Git locale

Configurare la distribuzione Git locale nell'app Web con il comando az webapp deployment source config-local-git.

Il servizio app supporta molti modi per distribuire contenuti a un'app Web, ad esempio FTP, istanza Git locale, GitHub, Visual Studio Team Services e BitBucket. Per questa guida introduttiva si distribuirà un'istanza Git locale. In altre parole, per la distribuzione verrà usato un comando Git che eseguirà il push da un repository locale a un repository in Azure.

Nel comando seguente sostituire <nome_app> con il nome dell'app Web.

az webapp deployment source config-local-git --name <app_name> --resource-group myResourceGroup --query url --output tsv

L'output presenta il formato seguente:

https://<username>@<app_name>.scm.azurewebsites.net:443/<app_name>.git

L'elemento <username> corrisponde all'utente della distribuzione creato nel passaggio precedente.

Copiare l'URI visualizzato che sarà necessario nel passaggio successivo.

Effettuare il push in Azure da Git

Aggiungere un'istanza remota di Azure al repository Git locale.

git remote add azure <paste_copied_url_here>

Effettuare il push a un'istanza remota di Azure per distribuire l'applicazione PHP. Verrà richiesta la password specificata in precedenza durante la creazione dell'utente di distribuzione.

git push azure master

Durante la distribuzione, Servizio app di Azure comunica lo stato con Git.

Counting objects: 3, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 291 bytes | 0 bytes/s, done.
Total 3 (delta 2), reused 0 (delta 0)
remote: Updating branch 'master'.
remote: Updating submodules.
remote: Preparing deployment for commit id 'a5e076db9c'.
remote: Running custom deployment command...
remote: Running deployment command...
...
< Output has been truncated for readability >
Nota

Si può notare che, alla fine, il processo di distribuzione installa i pacchetti Composer. Il servizio app non esegue tali automazioni durante la distribuzione predefinita, pertanto questo repository di esempio include tre file aggiuntivi nella directory radice per abilitarlo:

  • .deployment - Questo file indica al servizio app di eseguire bash deploy.sh come script di distribuzione personalizzato.
  • deploy.sh - Script di distribuzione personalizzato. Se si esamina il file, si noterà che esegue php composer.phar install dopo npm install.
  • composer.phar - Gestione pacchetti Composer.

È possibile usare questo approccio per aggiungere uno o più passaggi alla distribuzione basata su Git al servizio app. Per altre informazioni, vedere Custom Deployment Script (Script di distribuzione personalizzata).

Passare all'app Web di Azure

Passare a http://<app_name>.azurewebsites.net e aggiungere alcune attività all'elenco.

App PHP in esecuzione nel Servizio app di Azure

L'app PHP basata su dati è in esecuzione nel servizio app di Azure.

Aggiornare il modello in locale e rieseguire la distribuzione

In questo passaggio viene apportata una modifica semplice al modello di dati task e all'app Web e quindi viene pubblicato l'aggiornamento in Azure.

Per lo scenario delle attività, l'applicazione viene modificata per poter contrassegnare un'attività come completata.

Aggiungere una colonna

Nel terminale passare alla radice del repository Git.

Generare una nuova migrazione di database per la tabella tasks:

php artisan make:migration add_complete_column --table=tasks

Questo comando mostra il nome del file di migrazione che viene generato. Trovare il file in database/migrations e aprirlo.

Sostituire il metodo up con il codice seguente:

public function up()
{
    Schema::table('tasks', function (Blueprint $table) {
        $table->boolean('complete')->default(False);
    });
}

Il codice precedente aggiunge una colonna booleana nella tabella tasks denominata complete.

Sostituire il metodo down con il codice seguente per l'azione di ripristino dello stato precedente:

public function down()
{
    Schema::table('tasks', function (Blueprint $table) {
        $table->dropColumn('complete');
    });
}

Nel terminale eseguire le migrazioni del database Laravel per apportare la modifica nel database locale.

php artisan migrate

In base alla convenzione di denominazione Laravel, il modello Task (vedere app/Task.php) esegue il mapping alla tabella tasks per impostazione predefinita.

Aggiornare la logica dell'applicazione

Aprire il file routes/web.php. L'applicazione definisce qui le route e la logica di business.

Alla fine del file aggiungere una route con il codice seguente:

/**
 * Toggle Task completeness
 */
Route::post('/task/{id}', function ($id) {
    error_log('INFO: post /task/'.$id);
    $task = Task::findOrFail($id);

    $task->complete = !$task->complete;
    $task->save();

    return redirect('/');
});

Il codice precedente esegue un semplice aggiornamento del modello di dati tramite l'attivazione e la disattivazione del valore di complete.

Aggiornare la visualizzazione

Aprire il file resources/views/tasks.blade.php. Trovare il tag di apertura <tr> e sostituirlo con:

<tr class="{{ $task->complete ? 'success' : 'active' }}" >

Il codice precedente modifica il colore di riga in base al completamento dell'attività.

Nella riga successiva il codice è quello riportato di seguito:

<td class="table-text"><div>{{ $task->name }}</div></td>

Sostituire l'intera riga con il codice seguente:

<td>
    <form action="{{ url('task/'.$task->id) }}" method="POST">
        {{ csrf_field() }}

        <button type="submit" class="btn btn-xs">
            <i class="fa {{$task->complete ? 'fa-check-square-o' : 'fa-square-o'}}"></i>
        </button>
        {{ $task->name }}
    </form>
</td>

Il codice precedente aggiunge il pulsante di invio che fa riferimento alla route definita in precedenza.

Testare le modifiche in locale

Dalla directory radice del repository Git eseguire il server di sviluppo.

php artisan serve

Per visualizzare la modifica dello stato dell'attività, passare a http://localhost:8000 e selezionare la casella di controllo.

Casella di controllo aggiuntiva all'attività

Per arrestare PHP, digitare Ctrl + C nel terminale.

Pubblicare le modifiche in Azure

Nel terminale eseguire le migrazioni del database Laravel con la stringa di connessione di produzione per apportare la modifica nel database di Azure.

php artisan migrate --env=production --force

Eseguire il commit di tutte le modifiche in Git e quindi effettuare il push delle modifiche al codice in Azure.

git add .
git commit -m "added complete checkbox"
git push azure master

Dopo aver completato git push, passare all'app Web di Azure e testare la nuova funzionalità.

Modifiche al modello e al database pubblicate in Azure

Le attività aggiunte vengono mantenute nel database. Gli aggiornamenti allo schema di dati non modificano i dati esistenti.

Eseguire lo streaming dei log di diagnostica

Mentre l'applicazione PHP è in esecuzione nel servizio app di Azure, è possibile fare in modo che i log di console siano inviati tramite pipe al terminale. Ciò consente di ottenere gli stessi messaggi di diagnostica per il debug degli errori dell'applicazione.

Per avviare lo streaming dei log, usare il comando az webapp log tail.

az webapp log tail \
    --name <app_name> \
    --resource-group myResourceGroup

Dopo avere avviato lo streaming dei log, aggiornare l'app Web di Azure nel browser per ricevere traffico Web. I log di console vengono inviati tramite pipe al terminale. Se i log di console non sono immediatamente visibili, controllare nuovamente dopo 30 secondi.

Per interrompere lo streaming dei log in qualsiasi momento, digitare Ctrl+C.

Suggerimento

Un'applicazione PHP può usare lo standard error_log() da inviare alla console. L'applicazione di esempio usa questo approccio in app/Http/routes.php.

Come framework Web, Laravel usa Monolog come provider di registrazione. Per informazioni su come fare in modo che Monolog invii messaggi alla console, vedere PHP: How to use monolog to log to console (php://out) (PHP: procedura per usare Monolog per registrarsi alla console (php://out)).

Gestire l'app Web di Azure

Accedere al portale di Azure per gestire l'app Web creata.

Nel menu a sinistra fare clic su Servizi app e quindi sul nome dell'app Web di Azure.

Passare all'app Web di Azure nel portale

Verrà visualizzata la pagina di panoramica dell'app Web. Nella pagina è possibile eseguire attività di gestione di base come l'arresto, l'avvio, il riavvio e l'eliminazione.

Il menu a sinistra consente di visualizzare le pagine di configurazione dell'app.

Pagina del servizio app nel portale di Azure

Pulire le risorse

Per pulire le risorse, eseguire questo comando:

az group delete --name myResourceGroup

Passaggi successivi

In questa esercitazione si è appreso come:

  • Creare un database MySQL in Azure
  • Connettere un'app PHP a MySQL
  • Distribuire l'app in Azure
  • Aggiornare il modello di dati e ridistribuire l'app
  • Eseguire lo streaming dei log di diagnostica in Azure
  • Gestire l'app nel portale di Azure

Passare all'esercitazione successiva per apprendere come eseguire il mapping di un nome DNS personalizzato a un'app Web.