Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tutorial: creazione di un server Web e un’istanza database Amazon RDS
<a name="TUT_WebAppWithRDS"></a>

Questo tutorial descrive come installare un server Web Apache con PHP e creare un database MariaDB, MySQL o PostgreSQL. Il server Web viene eseguito in un'istanza Amazon EC2 utilizzando Amazon Linux 2023 e puoi scegliere tra un'istanza database MySQL o PostgreSQL. Sia l'istanza Amazon EC2 che l'istanza database vengono eseguite in un virtual private cloud (VPC) basato sul servizio Amazon VPC. 

**Importante**  
La creazione di un account è gratuita. AWS Tuttavia, completando questo tutorial, potresti incorrere in costi per le AWS risorse che utilizzi. È possibile eliminare queste risorse dopo aver completato l'esercitazione se non sono più necessarie.

**Nota**  
Questo tutorial funziona con Amazon Linux 2023 e potrebbe non funzionare per altre versioni di Linux.

Nel tutorial che segue, viene creata un'istanza EC2 che utilizza VPC, sottoreti e gruppo di sicurezza predefiniti per Account AWS. In questo tutorial viene illustrato come creare l'istanza database e configurare automaticamente la connettività con l'istanza EC2 creata. Nel tutorial viene quindi mostrato come installare il server Web sull'istanza EC2. Il server Web viene connesso all'istanza database nel VPC utilizzando l'endpoint dell'istanza del database.

1. [Avvio di un’istanza EC2 per la connessione all’istanza database](CHAP_Tutorials.WebServerDB.LaunchEC2.md)

1. [Creazione di un'istanza database Amazon RDS](CHAP_Tutorials.WebServerDB.CreateDBInstance.md)

1. [Installazione di un server Web nell'istanza EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md)

Il seguente diagramma illustra la configurazione al completamento del tutorial.

![\[Scenario VPC singolo\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/con-VPC-sec-grp.png)


**Nota**  
Dopo aver completato il tutorial, è presente una sottorete pubblica e una privata in ogni zona di disponibilità del VPC.  Se preferisci invece configurare un nuovo VPC per questo scenario, completa le attività in [Tutorial: crea un VPC da utilizzare con un ) IPv4](CHAP_Tutorials.WebServerDB.CreateVPC.md).

# Avvio di un’istanza EC2 per la connessione all’istanza database
<a name="CHAP_Tutorials.WebServerDB.LaunchEC2"></a>

Crea un'istanza Amazon EC2 nella sottorete pubblica del VPC.

**Per avviare un'istanza EC2**

1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Nell'angolo in alto a destra di Console di gestione AWS, scegli Regione AWS dove vuoi creare l'istanza EC2.

1. Selezionare **Pannello di controllo EC2**, quindi **Avvia istanza**, come visualizzato di seguito.  
![\[Pannello di controllo EC2\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_11.png)

1. Scegli le seguenti impostazioni nella pagina **Avvia un'istanza**.

   1. Nell'area **Name and tags** (Nome e tag), in **Name** (Nome) inserisci **tutorial-ec2-instance-web-server**.

   1. In **Immagini applicazione e sistema operativo (Amazon Machine Image)**, scegli **Amazon Linux**, quindi **AMI Amazon Linux 2023**. Manteni i valori predefiniti per le altre opzioni.  
![\[Scegliere un'Amazon Machine Image\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_12.png)

   1. In **Instance type** (Tipo di istanza), scegli **t2.micro**.

   1. In **Key pair (login)** (Coppia di chiavi (login), per **Key pair name** (Nome della coppia di chiavi), scegli una coppia di chiavi esistente. Per creare una nuova coppia di chiavi per l'istanza Amazon EC2, scegli **Create new key pair** (Crea nuova coppia di chiavi) e quindi utilizza la finestra **Create key pair** (Crea coppia di chiavi) per crearla.

      Per ulteriori informazioni sulla creazione di una nuova coppia di chiavi, consulta [Creazione di una coppia di chiavi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html#create-a-key-pair) nella *Guida per l’utente di Amazon EC2*.

   1. In **Network settings** (Impostazioni di rete), imposta questi valori e conserva le impostazioni predefinite degli altri valori:
      + In **Allow SSH traffic from** (Consenti traffico SSH da), scegli l'origine delle connessioni SSH all'istanza EC2.

        È possibile scegliere **My IP** (Il mio IP) se l'indirizzo IP visualizzato è corretto per le connessioni SSH.

        In caso contrario, è possibile determinare l'indirizzo IP da utilizzare per connettersi alle istanze EC2 nel VPC utilizzando Secure Shell (SSH). Per determinare il tuo indirizzo IP pubblico, in un'altra finestra o scheda del browser, puoi utilizzare il servizio all'indirizzo. [https://checkip.amazonaws.com](https://checkip.amazonaws.com) Un esempio di indirizzo IP è `203.0.113.25/32`.

        In molti casi, è possibile eseguire la connessione tramite un fornitore di servizi Internet (ISP) o con la protezione di un firewall senza un indirizzo IP statico. In tal caso, accertati di determinare l'intervallo di indirizzi IP utilizzati dai computer client.
**avvertimento**  
Se utilizzi `0.0.0.0/0` per l'accesso SSH, consenti a tutti gli indirizzi IP di accedere alle istanze pubbliche utilizzando SSH. Questo approccio è accettabile per un breve periodo di tempo in un ambiente di test, ma non è sicuro per gli ambienti di produzione. In produzione, autorizza solo un determinato indirizzo IP o un intervallo di indirizzi per accedere alle istanze utilizzando SSH.
      + Attiva **Consenti il HTTPs traffico da Internet**.
      + Attiva **Allow HTTP traffic from the internet** (Autorizzare il traffico HTTP da Internet).  
![\[Configura i dettagli dell'istanza\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_14.png)

   1. Lascia i valori predefiniti per le sezioni rimanenti.

   1. Analizza un riepilogo della configurazione dell'istanza nel pannello **Summary** (Riepilogo) e, quando è tutto pronto, scegli **Launch instance** (Avvia istanza).

1. Nella pagina **Stato avvio** prendi nota dell'identificatore per la nuova istanza EC2, ad esempio: `i-1234567890abcdef0`.  
![\[Identificatore dell'istanza EC2 nella pagina Stato avvio.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/getting-started-ec2-id.png)

1. Scegli l'identificatore dell'istanza EC2 per aprire l'elenco delle istanze EC2, quindi seleziona l'istanza EC2.

1. Nella scheda **Dettagli**, annota i seguenti valori, necessari quando ti connetti tramite SSH:

   1. Nel **riepilogo dell'istanza**, annota il valore per **Public IPv4 DNS**.  
![\[Il nome DNS pubblico EC2 nella scheda Dettagli della pagina Istanze.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/easy-create-ec2-public-dns.png)

   1. In **Dettagli istanza**, annota il valore visualizzato in **Nome coppia di chiavi**.  
![\[Il nome della coppia di chiavi EC2 nella scheda Dettagli della pagina Istanze.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/easy-create-ec2-key-pair.png)

1. Attendi che **Instance state** (Stato istanza) per l'istanza sia **Running** (In esecuzione) prima di continuare.

1. Completo [Creazione di un'istanza database Amazon RDS](CHAP_Tutorials.WebServerDB.CreateDBInstance.md).

# Creazione di un'istanza database Amazon RDS
<a name="CHAP_Tutorials.WebServerDB.CreateDBInstance"></a>

Crea un'istanza database RDS per MariaDB, RDS per MySQL or RDS per PostgreSQL che mantiene i dati utilizzati da un'applicazione Web. 

------
#### [ RDS for MariaDB ]

**Creazione di un'istanza database MariaDB**

1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Nell'angolo in alto a destra della Console di gestione AWS, seleziona la Regione AWS. Deve essere identica a quella in cui hai creato l'istanza EC2.

1. Nel riquadro di navigazione, scegliere **Databases (Database)**.

1. Scegliere **Crea database**.

1. Nella pagina **Crea database** scegli **Creazione standard**.

1. In **Opzioni motore**, seleziona **MariaDB**.  
![\[Seleziona il tipo di motore\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tutorial-create-mariadb.png)

1. Per **Modelli**, scegli **Piano gratuito** o **Sandbox**. **Piano gratuito** viene visualizzato per gli account con piano gratuito. **Sandbox** viene visualizzato per gli account con piani a pagamento.  
![\[Seleziona il modello\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tutorial-create-template.png)

1. Nella sezione **Availability and durability** (Disponibilità e durata), mantieni i valori predefiniti.

1. Nella sezione **Settings (Impostazioni)** impostare questi valori:
   + **DB Instance Identifier** (Identificatore istanze database): **tutorial-db-instance**
   + **Master username** (Nome utente master): digita **tutorial\$1user**.
   + **Auto generate a password** (Genera automaticamente una password): lascia l'opzione disattivata.
   + **Master password** (Password master): scegli una password.
   + **Confirm password (Conferma la password):** –digitare di nuovo la password.  
![\[Sezioni impostazioni\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Settings.png)

1. Nella sezione **Instance configuration** (Configurazione dell'istanza), imposta i seguenti valori:
   + **Classi espandibili (include le classi t)**
   + **db.t3.micro**  
![\[Sezione di configurazione dell'istanza\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_DB_instance_micro.png)

1. Nella sezione **Storage** (Archiviazione), mantieni le impostazioni di default.

1. Nella sezione **Connectivity** (Connettività), imposta i seguenti valori e lascia gli altri valori come predefiniti:
   + In **Compute resource** (Risorse di calcolo), seleziona **Connect to an EC2 compute resource** (Connetti a una risorsa di calcolo EC2).
   + In **EC2 instance** (Istanza EC2), scegli l'istanza EC2 creata in precedenza, ad esempio **tutorial-ec2-instance-web-server**.  
![\[Sezione connettività\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Connectivity.png)

1. Nella sezione **Autenticazione database** verifica che sia selezionata l'opzione **Autenticazione con password**.

1. Aprire la sezione **Additional configuration (Configurazione aggiuntiva)** e specificare **sample** per **Initial database name (Nome database iniziale)**. Lasciare le impostazioni predefinite per le altre opzioni.

1. Per creare l'istanza MariaDB, scegli **Crea database**.

   La nuova istanza database apparirà nell'elenco **Databases** con lo stato **Creating (Creazione in corso)**.

1. Attendere che lo **Status (Stato)** della nuova istanza database appaia come **Available (Disponibile)**. Quindi scegliere il nome dell'istanza database per visualizzarne i dettagli.

1. Nella sezione **Connectivity & security (Connettività e sicurezza**, visualizzare **Endpoint** e **Port (Porta)** dell'istanza database.  
![\[Dettagli istanza database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Endpoint_Port.png)

   Prendere nota dell'endpoint e della porta dell'istanza database. Queste informazioni verranno utilizzate per effettuare la connessione del server Web all'istanza del database.

1. Completo [Installazione di un server Web nell'istanza EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md).

------
#### [ RDS for MySQL ]

**Per creare un'istanza database MySQL**

1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Nell'angolo in alto a destra della Console di gestione AWS, seleziona la Regione AWS. Deve essere identica a quella in cui hai creato l'istanza EC2.

1. Nel riquadro di navigazione, scegliere **Databases (Database)**.

1. Scegliere **Crea database**.

1. Nella pagina **Crea database** scegli **Creazione standard**.

1. In **Opzioni motore**, seleziona **MySQL**.  
![\[Seleziona il tipo di motore\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tutorial-create-mysql.png)

1. Per **Modelli**, scegli **Piano gratuito** o **Sandbox**. **Piano gratuito** viene visualizzato per gli account con piano gratuito. **Sandbox** viene visualizzato per gli account con piani a pagamento.  
![\[Seleziona il modello\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tutorial-create-template.png)

1. Nella sezione **Availability and durability** (Disponibilità e durata), mantieni i valori predefiniti.

1. Nella sezione **Settings (Impostazioni)** impostare questi valori:
   + **DB Instance Identifier** (Identificatore istanze database): **tutorial-db-instance**
   + **Master username** (Nome utente master): digita **tutorial\$1user**.
   + **Auto generate a password** (Genera automaticamente una password): lascia l'opzione disattivata.
   + **Master password** (Password master): scegli una password.
   + **Confirm password (Conferma la password):** –digitare di nuovo la password.  
![\[Sezioni impostazioni\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Settings.png)

1. Nella sezione **Instance configuration** (Configurazione dell'istanza), imposta i seguenti valori:
   + **Classi espandibili (include le classi t)**
   + **db.t3.micro**  
![\[Sezione di configurazione dell'istanza\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_DB_instance_micro.png)

1. Nella sezione **Storage** (Archiviazione), mantieni le impostazioni di default.

1. Nella sezione **Connectivity** (Connettività), imposta i seguenti valori e lascia gli altri valori come predefiniti:
   + In **Compute resource** (Risorse di calcolo), seleziona **Connect to an EC2 compute resource** (Connetti a una risorsa di calcolo EC2).
   + In **EC2 instance** (Istanza EC2), scegli l'istanza EC2 creata in precedenza, ad esempio **tutorial-ec2-instance-web-server**.  
![\[Sezione connettività\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Connectivity.png)

1. Nella sezione **Autenticazione database** verifica che sia selezionata l'opzione **Autenticazione con password**.

1. Aprire la sezione **Additional configuration (Configurazione aggiuntiva)** e specificare **sample** per **Initial database name (Nome database iniziale)**. Lasciare le impostazioni predefinite per le altre opzioni.

1. Per creare l'istanza database MySQL, scegli **Crea database**.

   La nuova istanza database apparirà nell'elenco **Databases** con lo stato **Creating (Creazione in corso)**.

1. Attendere che lo **Status (Stato)** della nuova istanza database appaia come **Available (Disponibile)**. Quindi scegliere il nome dell'istanza database per visualizzarne i dettagli.

1. Nella sezione **Connectivity & security (Connettività e sicurezza**, visualizzare **Endpoint** e **Port (Porta)** dell'istanza database.  
![\[Dettagli istanza database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Endpoint_Port.png)

   Prendere nota dell'endpoint e della porta dell'istanza database. Queste informazioni verranno utilizzate per effettuare la connessione del server Web all'istanza del database.

1. Completo [Installazione di un server Web nell'istanza EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md).

------
#### [ RDS for PostgreSQL ]

**Creazione di un'istanza database PostgreSQL**

1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).

1. Nell'angolo in alto a destra della Console di gestione AWS, seleziona la Regione AWS. Deve essere identica a quella in cui hai creato l'istanza EC2.

1. Nel riquadro di navigazione, scegliere **Databases (Database)**.

1. Scegliere **Crea database**.

1. Nella pagina **Crea database** scegli **Creazione standard**.

1. In **Opzioni motore**, seleziona **PostgreSQL**.  
![\[Seleziona il tipo di motore\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tutorial-create-postgres.png)

1. Per **Modelli**, scegli **Piano gratuito** o **Sandbox**. **Piano gratuito** viene visualizzato per gli account con piano gratuito. **Sandbox** viene visualizzato per gli account con piani a pagamento.  
![\[Seleziona il modello\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/tutorial-create-template.png)

1. Nella sezione **Availability and durability** (Disponibilità e durata), mantieni i valori predefiniti.

1. Nella sezione **Settings (Impostazioni)** impostare questi valori:
   + **DB Instance Identifier** (Identificatore istanze database): **tutorial-db-instance**
   + **Master username** (Nome utente master): digita **tutorial\$1user**.
   + **Auto generate a password** (Genera automaticamente una password): lascia l'opzione disattivata.
   + **Master password** (Password master): scegli una password.
   + **Confirm password (Conferma la password):** –digitare di nuovo la password.  
![\[Sezioni impostazioni\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Settings.png)

1. Nella sezione **Instance configuration** (Configurazione dell'istanza), imposta i seguenti valori:
   + **Classi espandibili (include le classi t)**
   + **db.t3.micro**  
![\[Sezione di configurazione dell'istanza\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_DB_instance_micro.png)

1. Nella sezione **Storage** (Archiviazione), mantieni le impostazioni di default.

1. Nella sezione **Connectivity** (Connettività), imposta i seguenti valori e lascia gli altri valori come predefiniti:
   + In **Compute resource** (Risorse di calcolo), seleziona **Connect to an EC2 compute resource** (Connetti a una risorsa di calcolo EC2).
   + In **EC2 instance** (Istanza EC2), scegli l'istanza EC2 creata in precedenza, ad esempio **tutorial-ec2-instance-web-server**.  
![\[Sezione connettività\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Connectivity.png)

1. Nella sezione **Autenticazione database** verifica che sia selezionata l'opzione **Autenticazione con password**.

1. Aprire la sezione **Additional configuration (Configurazione aggiuntiva)** e specificare **sample** per **Initial database name (Nome database iniziale)**. Lasciare le impostazioni predefinite per le altre opzioni.

1. Per creare l'istanza database PostgreSQL, scegli **Crea database**.

   La nuova istanza database apparirà nell'elenco **Databases** con lo stato **Creating (Creazione in corso)**.

1. Attendere che lo **Status (Stato)** della nuova istanza database appaia come **Available (Disponibile)**. Quindi scegliere il nome dell'istanza database per visualizzarne i dettagli.

1. Nella sezione **Connectivity & security (Connettività e sicurezza**, visualizzare **Endpoint** e **Port (Porta)** dell'istanza database.  
![\[Dettagli istanza database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/Tutorial_WebServer_Endpoint_Port_postgres.png)

   Prendere nota dell'endpoint e della porta dell'istanza database. Queste informazioni verranno utilizzate per effettuare la connessione del server Web all'istanza del database.

1. Completo [Installazione di un server Web nell'istanza EC2](CHAP_Tutorials.WebServerDB.CreateWebServer.md).

------

# Installazione di un server Web nell'istanza EC2
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer"></a>

Installa un server Web in un'istanza EC2 creata in [Avvio di un’istanza EC2 per la connessione all’istanza database](CHAP_Tutorials.WebServerDB.LaunchEC2.md). Il server Web si connette all'istanza database Amazon RDS creata in [Creazione di un'istanza database Amazon RDS](CHAP_Tutorials.WebServerDB.CreateDBInstance.md). 

## Installazione di un server Web Apache con PHP e MariaDB
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer.Apache"></a>

Esegui la connessione all'istanza EC2 e installa il server Web Apache.

**Per effettuare la connessione all'istanza EC2 e installare il server Web Apache con PHP.**

1. Esegui la connessione all’istanza EC2 creata in precedenza seguendo la procedura riportata in [Connessione all’istanza di Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) nella *Guida per l’utente per di Amazon EC2*.

   Ti consigliamo di connetterti all'istanza EC2 tramite SSH. Se l'utilità client SSH è installata su Windows, Linux o Mac, puoi connetterti all'istanza utilizzando il comando nel seguente formato:

   ```
   ssh -i location_of_pem_file ec2-user@ec2-instance-public-dns-name
   ```

   Ad esempio, supponi che `ec2-database-connect-key-pair.pem` sia archiviato in `/dir1` su Linux e che il DNS IPv4 pubblico per l'istanza EC2 sia `ec2-12-345-678-90.compute-1.amazonaws.com`. Il comando SSH sarà simile al seguente:

   ```
   ssh -i /dir1/ec2-database-connect-key-pair.pem ec2-user@ec2-12-345-678-90.compute-1.amazonaws.com
   ```

1. Ottieni le ultime correzioni di bug e gli aggiornamenti di sicurezza aggiornando il software sulla tua istanza EC2. A questo scopo, eseguire il comando seguente.
**Nota**  
L'opzione `-y` installa gli aggiornamenti senza chiedere conferma. Per esaminare gli aggiornamenti prima di installarli, omettere questa opzione.

   ```
   sudo dnf update -y
   ```

1. Al completamento degli aggiornamenti, installa il server Web Apache, PHP e il software MariaDB utilizzando i comandi seguenti. Con questo comando vengono installati contemporaneamente più pacchetti software e dipendenze correlate.

------
#### [ MariaDB & MySQL ]

   ```
   sudo dnf install -y httpd php php-mysqli mariadb105
   ```

------
#### [ PostgreSQL ]

   ```
   sudo dnf install -y httpd php php-pgsql postgresql15
   ```

------

   Se si verifica un errore, è possibile che l'istanza non sia stata lanciata con un'AMI Amazon Linux 2023. Puoi invece utilizzare l'AMI Amazon Linux 2. È possibile visualizzare la versione di Amazon Linux con il comando seguente.

   ```
   cat /etc/system-release
   ```

   Per ulteriori informazioni, consulta la pagina relativa all'[aggiornamento del software dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/install-updates.html).

1. Avviare il server Web con il comando visualizzato di seguito.

   ```
   sudo systemctl start httpd
   ```

   È possibile verificare che il server Web sia installato e avviato correttamente. A tale scopo, immettere il nome DNS (Domain Name System) pubblico dell'istanza EC2 nella barra degli indirizzi di un browser Web, ad esempio: `http://ec2-42-8-168-21.us-west-1.compute.amazonaws.com`. Se il server Web è in esecuzione, verrà visualizzata la pagina di test di Apache. 

   Se la pagina di test Apache non viene visualizzata, controllare le regole in entrata per il gruppo di sicurezza VPC creato in [Tutorial: crea un VPC da utilizzare con un ) IPv4](CHAP_Tutorials.WebServerDB.CreateVPC.md). Assicurati che le regole in entrata ne includano una che consenta l'accesso HTTP (porta 80) per l'indirizzo IP utilizzato per connettersi al server Web.
**Nota**  
La pagina di test di Apache viene visualizzata solo quando la directory principale dei documenti è vuota, `/var/www/html`. Dopo aver aggiunto contenuti alla directory root dei documenti, i contenuti vengono visualizzati all'indirizzo DNS pubblico dell'istanza EC2. Prima di questo punto, vengono visualizzati nella pagina di test di Apache.

1. Configurare il server Web affinché si avvii a ogni avvio del sistema tramite il comando `systemctl`.

   ```
   sudo systemctl enable httpd
   ```

Per permettere a `ec2-user` di gestire file nella directory principale predefinita del server Web Apache, è necessario modificare la proprietà e le autorizzazioni della directory `/var/www`. Sono disponibili molti modi per completare questa attività. In questo tutorial, aggiungi l'utente `ec2-user` al gruppo `apache` per assegnare la proprietà del gruppo `apache` della directory `/var/www` e assegnare autorizzazioni di scrittura al gruppo.

**Per impostare le autorizzazioni dei file sul server Web Apache**

1. Aggiungere l'utente `ec2-user` al gruppo `apache`.

   ```
   sudo usermod -a -G apache ec2-user
   ```

1. Per aggiornare le autorizzazioni e includere il nuovo gruppo `apache`, eseguire la disconnessione.

   ```
   exit
   ```

1. Effettuare nuovamente l'accesso e verificare che il gruppo `apache` esista mediante il comando `groups`.

   ```
   groups
   ```

   L'output avrà un aspetto simile al seguente:

   ```
   ec2-user adm wheel apache systemd-journal
   ```

1. Cambiare la proprietà del gruppo della directory `/var/www` e dei suoi contenuti sul gruppo `apache`.

   ```
   sudo chown -R ec2-user:apache /var/www
   ```

1. Cambiare le autorizzazioni della directory `/var/www` e delle sue sottodirectory per aggiungere le autorizzazioni di scrittura di gruppo e impostare l'ID di gruppo per le sottodirectory create in futuro.

   ```
   sudo chmod 2775 /var/www
   find /var/www -type d -exec sudo chmod 2775 {} \;
   ```

1. Cambiare le autorizzazioni in modo ricorsivo per i file nella directory `/var/www` e nelle sue sottodirectory per aggiungere le autorizzazioni di scrittura di gruppo.

   ```
   find /var/www -type f -exec sudo chmod 0664 {} \;
   ```

Ora, `ec2-user` (e qualsiasi membro futuro del gruppo `apache`) può aggiungere, eliminare e modificare i file nella root del documento di Apache. Questo consente di aggiungere contenuti, ad esempio un sito Web statico o un'applicazione PHP. 

**Nota**  
Un server Web che esegue il protocollo HTTP non offre alcuna sicurezza di trasporto per i dati inviati e ricevuti. Quando ti connetti a un server HTTP tramite un browser Web, la molte informazioni sono visibili a persone non autorizzate in qualsiasi punto del percorso di rete. Queste informazioni includono ciò URLs che visiti, il contenuto delle pagine Web che ricevi e il contenuto (comprese le password) di qualsiasi modulo HTML.   
La best practice per la protezione del tuo server Web prevede l'installazione del supporto per HTTPS (HTTP Secure). Questo protocollo protegge i dati con la SSL/TLS crittografia. Per ulteriori informazioni, consulta [Tutorial: Configure SSL/TLS with the Amazon Linux AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/SSL-on-amazon-linux-ami.html) nella *Amazon EC2 User* Guide.

## Connessione del server web Apache all'istanza
<a name="CHAP_Tutorials.WebServerDB.CreateWebServer.PHPContent"></a>

Successivamente, aggiungere contenuti al server Web Apache che effettua la connessione all'istanza database Amazon RDS.

**Per aggiungere contenuti al server Web Apache che effettua la connessione all'istanza database.**

1. Mentre è ancora in corso la connessione all'istanza EC2, modificare la directory in `/var/www` e creare una nuova sottodirectory denominata `inc`.

   ```
   cd /var/www
   mkdir inc
   cd inc
   ```

1. Creare un nuovo file nella directory `inc` denominato `dbinfo.inc` e poi modificarlo con nano (o un altro editor a scelta).

   ```
   >dbinfo.inc
   nano dbinfo.inc
   ```

1. Aggiungi i seguenti contenuti al file `dbinfo.inc`. 
**Nota**  
Si consiglia di inserire le informazioni relative al nome utente e alla password in una cartella che non fa parte della directory principale del documento per il server Web. In questo modo si riduce la possibilità che le informazioni di sicurezza vengano esposte.  
Assicurati di modificare `master password` in una password adatta per la tua applicazione.

   ```
   <?php
   
   define('DB_SERVER', 'db_instance_endpoint');
   define('DB_USERNAME', 'tutorial_user');
   define('DB_PASSWORD', 'master password');
   define('DB_DATABASE', 'sample');
   ?>
   ```

1. Salvare e chiudere il file `dbinfo.inc`. Se stai usando nano, salva e chiudi il file usando Ctrl\$1S e Ctrl\$1X.

1. Cambiare la directory in `/var/www/html`.

   ```
   cd /var/www/html
   ```

1. Creare un nuovo file nella directory `html` denominato `SamplePage.php` e poi modificarlo con nano (o un altro editor a scelta).

   ```
   >SamplePage.php
   nano SamplePage.php
   ```

1. Aggiungere i seguenti contenuti al file `SamplePage.php`:

------
#### [ MariaDB & MySQL ]

   ```
   <?php include "../inc/dbinfo.inc"; ?>
   <html>
   <body>
   <h1>Sample page</h1>
   <?php
   
     /* Connect to MySQL and select the database. */
     $connection = mysqli_connect(DB_SERVER, DB_USERNAME, DB_PASSWORD);
   
     if (mysqli_connect_errno()) echo "Failed to connect to MySQL: " . mysqli_connect_error();
   
     $database = mysqli_select_db($connection, DB_DATABASE);
   
     /* Ensure that the EMPLOYEES table exists. */
     VerifyEmployeesTable($connection, DB_DATABASE);
   
     /* If input fields are populated, add a row to the EMPLOYEES table. */
     $employee_name = htmlentities($_POST['NAME']);
     $employee_address = htmlentities($_POST['ADDRESS']);
   
     if (strlen($employee_name) || strlen($employee_address)) {
       AddEmployee($connection, $employee_name, $employee_address);
     }
   ?>
   
   <!-- Input form -->
   <form action="<?PHP echo $_SERVER['SCRIPT_NAME'] ?>" method="POST">
     <table border="0">
       <tr>
         <td>NAME</td>
         <td>ADDRESS</td>
       </tr>
       <tr>
         <td>
           <input type="text" name="NAME" maxlength="45" size="30" />
         </td>
         <td>
           <input type="text" name="ADDRESS" maxlength="90" size="60" />
         </td>
         <td>
           <input type="submit" value="Add Data" />
         </td>
       </tr>
     </table>
   </form>
   
   <!-- Display table data. -->
   <table border="1" cellpadding="2" cellspacing="2">
     <tr>
       <td>ID</td>
       <td>NAME</td>
       <td>ADDRESS</td>
     </tr>
   
   <?php
   
   $result = mysqli_query($connection, "SELECT * FROM EMPLOYEES");
   
   while($query_data = mysqli_fetch_row($result)) {
     echo "<tr>";
     echo "<td>",$query_data[0], "</td>",
          "<td>",$query_data[1], "</td>",
          "<td>",$query_data[2], "</td>";
     echo "</tr>";
   }
   ?>
   
   </table>
   
   <!-- Clean up. -->
   <?php
   
     mysqli_free_result($result);
     mysqli_close($connection);
   
   ?>
   
   </body>
   </html>
   
   
   <?php
   
   /* Add an employee to the table. */
   function AddEmployee($connection, $name, $address) {
      $n = mysqli_real_escape_string($connection, $name);
      $a = mysqli_real_escape_string($connection, $address);
   
      $query = "INSERT INTO EMPLOYEES (NAME, ADDRESS) VALUES ('$n', '$a');";
   
      if(!mysqli_query($connection, $query)) echo("<p>Error adding employee data.</p>");
   }
   
   /* Check whether the table exists and, if not, create it. */
   function VerifyEmployeesTable($connection, $dbName) {
     if(!TableExists("EMPLOYEES", $connection, $dbName))
     {
        $query = "CREATE TABLE EMPLOYEES (
            ID int(11) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
            NAME VARCHAR(45),
            ADDRESS VARCHAR(90)
          )";
   
        if(!mysqli_query($connection, $query)) echo("<p>Error creating table.</p>");
     }
   }
   
   /* Check for the existence of a table. */
   function TableExists($tableName, $connection, $dbName) {
     $t = mysqli_real_escape_string($connection, $tableName);
     $d = mysqli_real_escape_string($connection, $dbName);
   
     $checktable = mysqli_query($connection,
         "SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_NAME = '$t' AND TABLE_SCHEMA = '$d'");
   
     if(mysqli_num_rows($checktable) > 0) return true;
   
     return false;
   }
   ?>
   ```

------
#### [ PostgreSQL ]

   ```
   <?php include "../inc/dbinfo.inc"; ?>
   
   <html>
   <body>
   <h1>Sample page</h1>
   <?php
   
   /* Connect to PostgreSQL and select the database. */
   $constring = "host=" . DB_SERVER . " dbname=" . DB_DATABASE . " user=" . DB_USERNAME . " password=" . DB_PASSWORD ;
   $connection = pg_connect($constring);
   
   if (!$connection){
    echo "Failed to connect to PostgreSQL";
    exit;
   }
   
   /* Ensure that the EMPLOYEES table exists. */
   VerifyEmployeesTable($connection, DB_DATABASE);
   
   /* If input fields are populated, add a row to the EMPLOYEES table. */
   $employee_name = htmlentities($_POST['NAME']);
   $employee_address = htmlentities($_POST['ADDRESS']);
   
   if (strlen($employee_name) || strlen($employee_address)) {
     AddEmployee($connection, $employee_name, $employee_address);
   }
   
   ?>
   
   <!-- Input form -->
   <form action="<?PHP echo $_SERVER['SCRIPT_NAME'] ?>" method="POST">
     <table border="0">
       <tr>
         <td>NAME</td>
         <td>ADDRESS</td>
       </tr>
       <tr>
         <td>
       <input type="text" name="NAME" maxlength="45" size="30" />
         </td>
         <td>
       <input type="text" name="ADDRESS" maxlength="90" size="60" />
         </td>
         <td>
       <input type="submit" value="Add Data" />
         </td>
       </tr>
     </table>
   </form>
   <!-- Display table data. -->
   <table border="1" cellpadding="2" cellspacing="2">
     <tr>
       <td>ID</td>
       <td>NAME</td>
       <td>ADDRESS</td>
     </tr>
   
   <?php
   
   $result = pg_query($connection, "SELECT * FROM EMPLOYEES");
   
   while($query_data = pg_fetch_row($result)) {
     echo "<tr>";
     echo "<td>",$query_data[0], "</td>",
          "<td>",$query_data[1], "</td>",
          "<td>",$query_data[2], "</td>";
     echo "</tr>";
   }
   ?>
   </table>
   
   <!-- Clean up. -->
   <?php
   
     pg_free_result($result);
     pg_close($connection);
   ?>
   </body>
   </html>
   
   
   <?php
   
   /* Add an employee to the table. */
   function AddEmployee($connection, $name, $address) {
      $n = pg_escape_string($name);
      $a = pg_escape_string($address);
      echo "Forming Query";
      $query = "INSERT INTO EMPLOYEES (NAME, ADDRESS) VALUES ('$n', '$a');";
   
      if(!pg_query($connection, $query)) echo("<p>Error adding employee data.</p>"); 
   }
   
   /* Check whether the table exists and, if not, create it. */
   function VerifyEmployeesTable($connection, $dbName) {
     if(!TableExists("EMPLOYEES", $connection, $dbName))
     {
        $query = "CREATE TABLE EMPLOYEES (
            ID serial PRIMARY KEY,
            NAME VARCHAR(45),
            ADDRESS VARCHAR(90)
          )";
   
        if(!pg_query($connection, $query)) echo("<p>Error creating table.</p>"); 
     }
   }
   /* Check for the existence of a table. */
   function TableExists($tableName, $connection, $dbName) {
     $t = strtolower(pg_escape_string($tableName)); //table name is case sensitive
     $d = pg_escape_string($dbName); //schema is 'public' instead of 'sample' db name so not using that
   
     $query = "SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_NAME = '$t';";
     $checktable = pg_query($connection, $query);
   
     if (pg_num_rows($checktable) >0) return true;
     return false;
   
   }
   ?>
   ```

------

1. Salvare e chiudere il file `SamplePage.php`.

1. Verificare che il server Web effettui correttamente la connessione all'istanza  aprendo un browser web e navigando fino a `http://EC2 instance endpoint/SamplePage.php`, ad esempio: `http://ec2-12-345-67-890.us-west-2.compute.amazonaws.com/SamplePage.php`.

È possibile utilizzare `SamplePage.php` per aggiungere dati all'istanza. I dati aggiunti verranno visualizzati nella pagina. Per verificare che i dati siano stati inseriti nella tabella, installa il client MySQL nell'istanza Amazon EC2. Esegui quindi la connessione all'istanza database ed esegui la query sulla tabella. 

Per informazioni sull’istallazione di un client SQL e la connessione a un'istanza database Oracle, consulta [Connessione all’istanza database MySQL](USER_ConnectToInstance.md).

Per assicurarsi che l’istanza sia il più possibile sicura, verificare che le fonti esterne al VPC non possano connettersi all’istanza. 

Dopo aver terminato il test del server Web e del database, è necessario eliminare l' il cluster DB e l'istanza Amazon EC2.
+ Per eliminare un’istanza database, segui le istruzioni riportate in [Eliminazione di un'istanza database](USER_DeleteInstance.md). Non è necessario creare uno snapshot finale.
+ Per terminare un'istanza Amazon EC2, segui le istruzioni riportate in [Termina istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) nella *Guida per l'utente di Amazon EC2*.