Esercizio - Connettersi al database e aggiungere dati di esempio

15 minuti

Prima di connettere il database all'app, è necessario verificare che sia possibile connettersi, aggiungere una tabella di base e lavorare con dati di esempio.

L'infrastruttura, gli aggiornamenti software e le patch per il database SQL di Azure sono gestiti da Microsoft. È possibile gestire il database SQL di Azure come qualsiasi altra installazione di SQL Server. È ad esempio possibile usare Visual Studio, SQL Server Management Studio, Azure Data Studio o altri strumenti per gestire il database SQL di Azure.

È l'utente che deve scegliere come accedere al database e connetterlo all'app. Per acquisire familiarità con il database, è possibile connettersi direttamente al database dal portale, creare una tabella ed eseguire alcune operazioni CRUD di base. Si apprenderanno i concetti seguenti:

Che cos'è Cloud Shell e come accedervi dal portale.
Come accedere alle informazioni sul database dall'interfaccia della riga di comando di Azure, incluse le stringhe di connessione.
Come connettersi al database tramite sqlcmd.
Come inizializzare il database con una tabella di base e alcuni dati di esempio.

Che cos'è Azure Cloud Shell?

Azure Cloud Shell è un'esperienza shell basata su browser per gestire e sviluppare risorse di Azure. Cloud Shell può essere paragonato a una console interattiva che viene eseguita nel cloud.

In background, Cloud Shell viene eseguito su Linux. Tuttavia, a seconda del fatto che si preferisca un ambiente Linux o Windows, è possibile scegliere tra due esperienze: Bash e PowerShell.

Cloud Shell è accessibile da qualsiasi posizione. Oltre che dal portale, è possibile accedere a Cloud Shell anche da shell.azure.com, dall'app per dispositivi mobili di Azure o da Visual Studio Code.

Cloud Shell include strumenti ed editor di testo molto diffusi. Ecco una breve panoramica delle utilità az, jq e sqlcmd, tre strumenti che verranno usati per questo esercizio.

az è anche noto come interfaccia della riga di comando di Azure. Si tratta dell'interfaccia della riga di comando per l'uso delle risorse di Azure. L'interfaccia viene usata per ottenere informazioni sul database, inclusa la stringa di connessione.
jq è un parser JSON della riga di comando. È possibile inviare tramite pipe l'output dei comandi az a questo strumento per estrarre i campi importanti dall'output JSON.
sqlcmd consente di eseguire istruzioni in SQL Server. Si usa sqlcmd per creare una sessione interattiva con il Database SQL di Azure.

Ottenere informazioni sul database SQL di Azure

Prima di connettersi al database, è consigliabile verificare che esista e che sia online.

In questo caso si userà l'utilità az per elencare i database e visualizzare alcune informazioni sul database Logistics, tra cui la dimensione massima e lo stato.

I comandi az da eseguire richiedono il nome del gruppo di risorse e il nome del server logico di Azure SQL. Per evitare di doverli digitare ogni volta, eseguire questo comando azure configure per specificare i valori come predefiniti.

Sostituire [server-name] con il nome del server logico SQL di Azure creato e [resource-group] con il gruppo di risorse usato per il server.
```
az configure --defaults group=[resource-group] sql-server=[server-name]
```
Nota

A seconda del riquadro in cui ci si trova nel portale, il nome del server SQL potrebbe essere visualizzato come FQDN (ad esempio, servername.database.windows.net). Per questo comando è tuttavia necessario solo il nome logico senza il suffisso .database.windows.net.
Per elencare tutti i database nel server logico SQL di Azure, eseguire il comando az sql db list seguente:
```
az sql db list
```
Si otterrà un blocco di codice JSON di grandi dimensioni come output.
Poiché si è interessati a visualizzare solo i nomi dei database, eseguire il comando una seconda volta. Questa volta, tuttavia, inviare tramite pipe l'output a jq per visualizzare solo i campi del nome.
```
az sql db list | jq '[.[] | {name: .name}]'
```
Dovrebbe essere visualizzato questo output:
```
[
  {
    "name": "Logistics"
  },
  {
    "name": "master"
  }
]
```
Logistics è il database. Come in SQL Server, il database di sistema master include i metadati del server, ad esempio gli account di accesso e le impostazioni di configurazione di sistema.
Eseguire il comando az sql db show seguente per ottenere informazioni dettagliate sul database Logistics:
```
az sql db show --name Logistics
```
Come nel caso precedente, si noterà un blocco di codice JSON di grandi dimensioni come output.
Eseguire il comando una seconda volta. Questa volta inviare tramite pipe l'output a jq per limitare l'output solo al nome, alla dimensione massima e allo stato del database Logistics.
```
az sql db show --name Logistics | jq '{name: .name, maxSizeBytes: .maxSizeBytes, status: .status}'
```
Si noterà che il database è online e che è indicata la quantità massima di dati che il database è in grado di archiviare.
```
{
  "name": "Logistics",
  "maxSizeBytes": 2147483648,
  "status": "Online"
}
```

Connettersi al database

Dopo aver ottenuto queste informazioni sul database, è possibile connettersi tramite sqlcmd, creare una tabella con informazioni sugli autisti ed eseguire alcune operazioni CRUD di base.

CRUD è l'acronimo di Create, Read, Update e Delete, vale a dire le operazioni di creazione, lettura, aggiornamento ed eliminazione. Si tratta delle operazioni eseguite sui dati di una tabella e sono le quattro operazioni di base necessarie per l'app. In questa fase, è consigliabile verificare che sia possibile eseguire ognuna di esse.

Eseguire il comando az sql db show-connection-string seguente per ottenere la stringa di connessione per il database Logistics in un formato utilizzabile da sqlcmd:
```
az sql db show-connection-string --client sqlcmd --name Logistics
```
L'output sarà simile all'esempio seguente. Copiare l'output per usarlo nel passaggio successivo.
```
"sqlcmd -S tcp:<server-name>.database.windows.net,1433 -d Logistics -U <username> -P <password> -N -l 30"
```
Per creare una sessione interattiva, eseguire l'istruzione sqlcmd ottenuta dall'output del passaggio precedente. Rimuovere le virgolette e sostituire <username> e <password> con il nome utente e la password specificati durante la creazione del database. Ecco un esempio:
```
sqlcmd -S tcp:<server-name>.database.windows.net,1433 -d Logistics -U martina -P 'password1234$' -N -l 30
```
Suggerimento

Racchiudere la password tra virgolette singole in modo che "&" e altri caratteri speciali non vengano interpretati come istruzioni di elaborazione.
Importante

Potrebbe essere visualizzato un messaggio di errore simile all'esempio seguente:
```
Sqlcmd: Error: Microsoft ODBC Driver 17 for SQL Server:
Cannot open server 'contoso' requested by the login.
Client with IP address 'nnn.nnn.nnn.nnn' is not allowed to access the server.
To enable access, use the Windows Azure Management Portal or run sp_set_firewall_rule
on the master database to create a firewall rule for this IP address or address range.
It may take up to five minutes for this change to take effect.
```
Se si verifica questo errore, è necessario aggiungere un'altra regola del firewall per il client. Per farlo, effettua i seguenti passaggi:
- Accedere al portale di Azure.
- Nella home page di Azure, in Servizi di Azure selezionare Tutte le risorse. Viene visualizzato il riquadro Tutte le risorse.
- Cercare e selezionare il proprio database. Viene visualizzato il riquadro Logistics per il database SQL.
- Nella barra dei menu in alto selezionare Imposta firewall server. Viene visualizzato il riquadro Rete.
- Nella sezione Regole del firewall selezionare Aggiungi regola firewall. Viene visualizzato il riquadro Aggiungi regola firewall.
- Specificare un valore univoco per Nome regola e quindi immettere l'indirizzo IP indicato nel messaggio di errore per entrambi i campi Indirizzo IP iniziale e Indirizzo IP finale. Seleziona OK.
- Seleziona Salva.
- Eseguire di nuovo l'istruzione sqlcmd per avviare la sessione sqlcmd interattiva. Il comando dovrebbe essere simile all'esempio seguente:
```
sqlcmd -S tcp:<server-name>.database.windows.net,1433 -d Logistics -U martina -P 'password1234$' -N -l 30
```
Dopo aver avviato la sessione di sqlcmd, i comandi rimanenti usano il linguaggio Transact-SQL o T-SQL.

Suggerimento

Quando si eseguono i comandi T-SQL in questo modulo, è possibile che GO nella seconda riga non venga copiato nel prompt sqlcmd. Dopo aver immesso la prima riga del comando, potrebbe essere necessario digitare il comando GO. Il comando T-SQL non viene eseguito senza di esso. Assicurarsi perciò di eseguire il comando GO.
Dalla sessione di sqlcmd eseguire le istruzioni T-SQL seguenti per creare una tabella denominata Drivers:
```
CREATE TABLE Drivers (DriverID int, LastName varchar(255), FirstName varchar(255), OriginCity varchar(255));
GO
```
La tabella contiene quattro colonne: un identificatore univoco, il nome e il cognome dell'autista e la città di origine dell'autista.

Eseguire le istruzioni T-SQL seguenti per verificare che esista la tabella Drivers:

SELECT name FROM sys.tables;
GO

Dovrebbe essere visualizzato questo output:

name
--------------------------------------------------------------------------------------------------------------------------------
Drivers

(1 rows affected)

Per testare l'operazione create, eseguire le istruzioni T-SQL seguenti per aggiungere una riga di esempio alla tabella:
```
INSERT INTO Drivers (DriverID, LastName, FirstName, OriginCity) VALUES (123, 'Zirne', 'Laura', 'Springfield');
GO
```
Questo output indica che l'operazione è riuscita:
```
(1 rows affected)
```
Per testare l'operazione read, eseguire le istruzioni T-SQL seguenti per elencare le colonne DriverID e OriginCity da tutte le righe nella tabella:
```
SELECT DriverID, OriginCity FROM Drivers;
GO
```
Viene visualizzato un solo risultato con i valori DriverID e OriginCity per la riga che è stata creata nel passaggio precedente.
```
DriverID    OriginCity
----------- --------------------------
        123 Springfield

(1 rows affected)
```
Per testare l'operazione update, eseguire le istruzioni T-SQL seguenti per modificare la città di origine da "Springfield" a "Boston" per l'autista con un valore DriverID pari a 123:
```
UPDATE Drivers SET OriginCity='Boston' WHERE DriverID=123;
GO
```
Eseguire le istruzioni T-SQL seguenti per elencare nuovamente le colonne DriverID e OriginCity:
```
SELECT DriverID, OriginCity FROM Drivers;
GO
```
Verrà ora visualizzato l'output seguente. Si noti come il valore OriginCity riflette l'aggiornamento a Boston.
```
DriverID    OriginCity
----------- --------------------------
        123 Boston

(1 rows affected)
```
Testare infine l'operazione delete eseguendo le istruzioni T-SQL seguenti per eliminare il record:
```
DELETE FROM Drivers WHERE DriverID=123;
GO
```
```
(1 rows affected)
```
Eseguire le istruzioni T-SQL seguenti per verificare che la tabella Drivers sia vuota:
```
SELECT COUNT(*) FROM Drivers;
GO
```
È possibile notare che la tabella non contiene righe.
```
-----------
          0

(1 rows affected)
```

Ora che si ha un'idea generale dell'uso del database SQL di Azure da Cloud Shell, è possibile ottenere la stringa di connessione per il proprio strumento di gestione SQL preferito, che si tratti di SQL Server Management Studio, Visual Studio o di un altro strumento.

Cloud Shell rende molto semplice accedere e usare le risorse di Azure. Poiché Cloud Shell è basato su browser, è possibile accedervi da Windows, macOS o Linux: essenzialmente da qualsiasi sistema dotato di un Web browser.

È stata acquisita esperienza pratica su come eseguire i comandi dell'interfaccia della riga di comando di Azure per ottenere informazioni sul database SQL di Azure. Sono inoltre state applicate le competenze relative a T-SQL.

Nell'unità successiva viene eseguito il wrapping di questo modulo e viene spiegato come eliminare il database.

Esercizio - Connettersi al database e aggiungere dati di esempio

Che cos'è Azure Cloud Shell?

Ottenere informazioni sul database SQL di Azure

Connettersi al database

Commenti e suggerimenti