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à.
# Configurazione del dispositivo
Questa sezione descrive come configurare il dispositivo per la connessione ad AWS IoT Core. Se vuoi iniziare AWS IoT Core ma non hai ancora un dispositivo, puoi creare un dispositivo virtuale usando Amazon EC2 oppure puoi usare il tuo PC Windows o Mac come dispositivo IoT.
Seleziona l'opzione di dispositivo migliore da provare AWS IoT Core. Certo, puoi provarli tutti, ma provane solo uno alla volta. Se non sei certo di quale opzione del dispositivo è più adatta a te, leggi come scegliere [quale opzione del dispositivo è la migliore](iot-gs-first-thing.md#choosing-a-gs-system) e poi torna a questa pagina.
**Opzioni del dispositivo**
+ [Crea un dispositivo virtuale con Amazon EC2](creating-a-virtual-thing.md)
+ [Usa il tuo PC o Mac Windows o Linux come dispositivo AWS IoT](using-laptop-as-device.md)
+ [Connettere un Raspberry Pi o altro dispositivo](connecting-to-existing-device.md)
# Crea un dispositivo virtuale con Amazon EC2
In questo tutorial, creerai un'istanza Amazon EC2 da utilizzare come dispositivo virtuale nel cloud.
Per completare questo tutorial, hai bisogno di un Account AWS. Se non disponi dell'account, effettua la procedura descritta in [Configurare Account AWS](setting-up.md), prima di continuare.
**Topics**
+ [Configurare un'istanza Amazon EC2](#set-up-ec2)
+ [Installa Git, Node.js e configura AWS CLI](#install-git-node)
+ [Crea AWS IoT risorse per il tuo dispositivo virtuale](#ec2-create-certificate)
+ [Installa l'SDK AWS IoT del dispositivo per JavaScript](#ec2-sdk)
+ [Esecuzione dell'applicazione di esempio](#ec2-run-app)
+ [Visualizza i messaggi dell'app di esempio nella AWS IoT console](#ec2-view-msg)
## Configurare un'istanza Amazon EC2
Nei passaggi seguenti viene illustrato come creare un'istanza Amazon EC2 che fungerà da dispositivo virtuale al posto di un dispositivo fisico.
Se è la prima volta che crei un'istanza Amazon EC2, potresti trovare più utili le istruzioni contenute nella [Guida introduttiva alle istanze Amazon EC2 Linux](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/EC2_GetStarted.html).
**Per avviare un'istanza**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dal menu della console a sinistra, espandi la sezione **Instances** (Istanze) e scegli **Istanze** (Istanze). Dalla dashboard **Istanze** (Istanze), scegli **Launch instances** (Avvia istanze) sulla destra per visualizzare un elenco di configurazioni di base.
1. Nella sezione **Name and tags** (Nome e tag), inserisci un nome per l'istanza e, facoltativamente, aggiungi tag.
1. Nella sezione **Immagini di applicazioni e sistema operativo (Amazon Machine Image)**, scegli un modello AMI per l'istanza, ad esempio *Amazon Linux 2 AMI (HVM)*. Nota che queste AMI sono contrassegnate dalla dicitura "Free tier eligible" (Idonea per il piano gratuito).
1. Nella sezione **Instance type** (Tipo di istanza), è possibile selezionare la configurazione hardware per l'istanza. Selezionare il tipo `t2.micro`, ovvero l'opzione selezionata per impostazione di default. Questo tipo di istanza è idoneo per il piano gratuito.
1. Nella sezione **Key pair (login)** (Coppia di chiavi (accesso)), scegli il nome di una coppia di chiavi dall'elenco a discesa o scegli **Create a new key pair** (Crea una nuova coppia di chiavi) per crearne una nuova. Quando crei una nuova coppia di chiavi, assicurati di scaricare il file della chiave privata e di salvarlo in un luogo sicuro, perché questa è l'unica possibilità che hai per scaricarlo e salvarlo. Dovrai fornire il nome della coppia di chiavi quando avvii un'istanza e la chiave privata corrispondente ogni volta che ti connetti all'istanza.
**avvertimento**
Non selezionare l'opzione **Proceed without a key pair ** (Procedi senza una coppia di chiavi). Se l'istanza viene avviata senza una coppia di chiavi, non sarà possibile connettersi a essa.
1. Nella sezione **Network settings** (Impostazioni di rete) e nella sezione **Configure storage** (Configura archiviazione), è possibile mantenere le impostazioni predefinite. Al termine, scegli **Launch Instances** (Avvia istanze).
1. Una pagina di conferma indicherà che l'istanza si sta avviando. Scegliere **View Instances (Visualizza istanze)** per chiudere la pagina di conferma e tornare alla console.
1. Nella schermata **Instances (Istanze)**, è possibile visualizzare lo stato dell'avvio. L'avvio di un'istanza richiede pochi minuti. Quando avvii un'istanza, il suo stato iniziale è `pending`. Dopo aver avviato l'istanza, il relativo stato cambia in `running` e l'istanza riceve un nome DNS pubblico. **(Se la colonna **Public DNS (IPv4)** è nascosta, scegli **Mostra/Nascondi colonne** (l'icona a forma di ingranaggio) nell'angolo in alto a destra della pagina, quindi seleziona Public DNS ().) IPv4**
1. Possono essere necessari alcuni minuti affinché l'istanza sia pronta e sia possibile connettervisi. Controllare che l'istanza abbia superato i controlli relativi allo stato. È possibile visualizzare queste informazioni nella colonna **Status Checks (Verifiche dello stato)**.
Dopo che la nuova istanza ha superato i controlli di stato, continua con la procedura successiva e connettiti ad essa.
**Per collegarsi all'istanza**
È possibile connettersi a un'istanza tramiteil client basato su browser selezionando l'istanza dalla console Amazon EC2 e scegliendo di effettuare la connessione tramite Amazon EC2 Instance Connect. Instance Connect gestisce le autorizzazioni e fornisce una connessione valida.
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel menu a sinistra, seleziona **Instances** (Istanze).
1. Selezionare l’istanza, quindi scegliere **Collegarsi**.
1. Scegli **Amazon EC2 Instance Connect**, **Connect** (Collega).
Ora dovresti disporre di una finestra **Amazon EC2 Instance Connect** che effettua l'accesso alla nuova istanza Amazon EC2.
## Installa Git, Node.js e configura AWS CLI
In questa sezione, installerai Git e Node.js, nell'istanza Linux.
**Per installare Git**
1. Nella finestra **Amazon EC2 Instance Connect**, esegui l'aggiornamento dell'istanza utilizzando il comando seguente.
```
sudo yum update -y
```
1. Nella finestra **Amazon EC2 Instance Connect**, installa Git utilizzando il comando seguente.
```
sudo yum install git -y
```
1. Per verificare se Git è stato installato e la versione corrente di Git, esegui il seguente comando:
```
git --version
```
**Per installare Node.js**
1. Nella finestra **Amazon EC2 Instance Connect**, installa il gestore delle versioni del nodo (nvm) utilizzando il seguente comando.
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash
```
Verrà utilizzato nvm per installare Node.js perché è in grado di installare più versioni di Node.js e consente di passare dall'una all'altra.
1. Nella finestra **Amazon EC2 Instance Connect**, attiva nvm utilizzando questo comando.
```
. ~/.nvm/nvm.sh
```
1. Nella finestra **Amazon EC2 Instance Connect**, utilizza nvm per installare la versione più recente di Node.js utilizzando questo comando.
```
nvm install 16
```
**Nota**
Installa l'ultima versione LTS di Node.js.
Installando Node.js, viene installato anche il gestore di pacchetti nodo (npm), quindi è possibile installare moduli aggiuntivi in base alle esigenze.
1. Nella finestra **Amazon EC2 Instance Connect** verifica che Node.js sia installato e funzioni correttamente utilizzando questo comando.
```
node -e "console.log('Running Node.js ' + process.version)"
```
Questo tutorial richiede Node 10.0 o versioni successive. Per ulteriori informazioni, consulta [Tutorial: Setting Up Node.js on an Amazon EC2 Instance](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html) (Tutorial: configurazione di Node.js su un'istanza Amazon EC2).
**Per configurare AWS CLI**
L'istanza Amazon EC2 viene precaricata con AWS CLI. Tuttavia, devi completare il tuo AWS CLI profilo. Per ulteriori informazioni su come configurare la tua CLI, consulta [Configurazione di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
1. L'esempio seguente illustra i valori di esempio. Sostituisci questi valori con i tuoi valori. Questi valori sono disponibili nella [console AWS nelle informazioni dell'account in **Security credentials (Credenziali di sicurezza)**](https://console.aws.amazon.com//iam/home#/security_credentials).
Nella finestra **Amazon EC2 Instance Connect**, immetti il comando:
```
aws configure
```
Quindi inserisci i valori dal tuo account alle richieste visualizzate.
```
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
1. Puoi testare la tua AWS CLI configurazione con questo comando:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Se il tuo AWS CLI è configurato correttamente, il comando dovrebbe restituire un indirizzo di endpoint inviato dal tuo Account AWS.
## Crea AWS IoT risorse per il tuo dispositivo virtuale
Questa sezione descrive come utilizzare AWS CLI per creare l'oggetto e i relativi file di certificato direttamente sul dispositivo virtuale. Questo viene fatto direttamente sul dispositivo per evitare le potenziali complicazioni che potrebbero derivare dalla copia sul dispositivo da un altro computer. In questa sezione, creerai le seguenti risorse per il tuo dispositivo virtuale:
+ Un oggetto in cui rappresentare il dispositivo virtuale AWS IoT.
+ Un certificato per autenticare il dispositivo virtuale.
+ Un documento di policy per autorizzare il dispositivo virtuale a connettersi ad AWS IoT e pubblicare, ricevere e sottoscrivere messaggi.
**Per creare un AWS IoT oggetto nell'istanza Linux**
I dispositivi collegati a AWS IoT sono rappresentati da *oggetti Thing* nel AWS IoT registro. Un *oggetto* rappresenta un dispositivo specifico o un'entità logica. In questo caso, il tuo *oggetto* rappresenta il dispositivo virtuale, questa istanza Amazon EC2.
1. Nella finestra **Amazon EC2 Instance Connect**, esegui il comando seguente per creare il tuo oggetto.
```
aws iot create-thing --thing-name "MyIotThing"
```
1. La risposta JSON deve essere simile alla seguente:
```
{
"thingArn": "arn:aws:iot:your-region:your-aws-account:thing/MyIotThing",
"thingName": "MyIotThing",
"thingId": "6cf922a8-d8ea-4136-f3401EXAMPLE"
}
```
**Per creare e allegare AWS IoT chiavi e certificati nella tua istanza Linux**
Il comando **[create-keys-and-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-keys-and-certificate.html)** crea certificati client firmati dall'autorità di certificazione root Amazon. Questo certificato viene utilizzato per autenticare l'identità del dispositivo virtuale.
1. Nell finestra **Amazon EC2 Instance Connect** crea una directory in cui archiviare i file del certificato e delle chiavi.
```
mkdir ~/certs
```
1. Nella finestra **Amazon EC2 Instance Connect**, scarica una copia del certificato dell'autorità di certificazione (CA) Amazon utilizzando questo comando.
```
curl -o ~/certs/Amazon-root-CA-1.pem \
https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
1. Nella finestra **Amazon EC2 Instance Connect**, esegui il comando seguente per creare la tua chiave privata e pubblica e i file del certificato X.509. Questo comando inoltre registra e attiva il certificato con. AWS IoT
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/device.pem.crt" \
--public-key-outfile "~/certs/public.pem.key" \
--private-key-outfile "~/certs/private.pem.key"
```
La risposta avrà il seguente aspetto. Salva il `certificateArn` in modo da poterlo utilizzare nei comandi successivi. Ne avrai bisogno per collegare il certificato al tuo oggetto e per allegare la policy al certificato in un passaggio successivo.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
"certificateId": "9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
"certificatePem": "
-----BEGIN CERTIFICATE-----
MIICiTCCEXAMPLE6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
VVMxCzAJBgNVBAgEXAMPLEAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAsTC0lBTSEXAMPLE2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYEXAMPLEb20wHhcNMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCEXAMPLEJBgNVBAgTAldBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDAEXAMPLEsTC0lBTSBDb25z
b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEXAMPLE25lQGFt
YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+aEXAMPLE
EXAMPLEfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
rDHudUZEXAMPLELG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
Ibb3OhjZnzcvQAEXAMPLEWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
nUhVVxYUntneD9+h8Mg9qEXAMPLEyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GuoEDEXAMPLEBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\nMMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\n59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\nhJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\nFQIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nkey omitted for security reasons\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. Nella finestra di **Amazon EC2 Instance Connect**, collega l'oggetto oggetto al certificato appena creato utilizzando il comando seguente e la *certificateArn* risposta del comando precedente.
```
aws iot attach-thing-principal \
--thing-name "MyIotThing" \
--principal "certificateArn"
```
Se va a buon fine, questo comando non restituisce alcun output.
**Creazione e collegamento di una policy**
1. Nella finestra **Amazon EC2 Instance Connect**, crea il file della policy copiando e incollando questo documento di policy in un file denominato **\$1/policy.json**.
Se non disponi di un editor Linux preferito, puoi aprire **nano**, utilizzando questo comando.
```
nano ~/policy.json
```
Incolla il documento di policy per `policy.json` in esso. Salva il file ed esci dall'editor di testo **nano** (Ctrl-X).
Contenuto del documento di policy per `policy.json`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect"
],
"Resource": [
"*"
]
}
]
}
```
1. Nella finestra **Amazon EC2 Instance Connect** crea la policy utilizzando il comando seguente.
```
aws iot create-policy \
--policy-name "MyIotThingPolicy" \
--policy-document "file://~/policy.json"
```
Output:
****
```
{
"policyName": "MyIotThingPolicy",
"policyArn": "arn:aws:iot:us-east-1:your-aws-account:policy/MyIotThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\",
\"iot:Subscribe\",
\"iot:Connect\"
],
\"Resource\": [
\"*\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. Nella finestra **Amazon EC2 Instance Connect**, collega la policy al certificato del dispositivo virtuale utilizzando il comando seguente.
```
aws iot attach-policy \
--policy-name "MyIotThingPolicy" \
--target "certificateArn"
```
Se va a buon fine, questo comando non restituisce alcun output.
## Installa l'SDK AWS IoT del dispositivo per JavaScript
In questa sezione installerai AWS IoT Device SDK for JavaScript, che contiene il codice con cui le applicazioni possono comunicare AWS IoT e i programmi di esempio. Per ulteriori informazioni, consulta [AWS IoT Device SDK for JavaScript GitHub repository](https://github.com/aws/aws-iot-device-sdk-js-v2).
**Per installare AWS IoT Device SDK for JavaScript sulla tua istanza Linux**
1. Nella finestra **Amazon EC2 Instance Connect**, clona il AWS IoT Device SDK for JavaScript repository nella `aws-iot-device-sdk-js-v2` directory della tua home directory usando questo comando.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Naviga nella directory `aws-iot-device-sdk-js-v2` creata nella fase precedente.
```
cd aws-iot-device-sdk-js-v2
```
1. Utilizzare npm per installare l'SDK.
```
npm install
```
## Esecuzione dell'applicazione di esempio
I comandi delle sezioni successive presuppongono che i file di chiave e certificato siano memorizzati sul dispositivo virtuale, come illustrato in questa tabella.
**Nomi dei file dei certificati**
| File | Percorso del file |
| --- | --- |
| Chiave privata | `~/certs/private.pem.key` |
| Certificato del dispositivo | `~/certs/device.pem.crt` |
| Un certificato emesso da una CA root | `~/certs/Amazon-root-CA-1.pem` |
In questa sezione, installerai ed eseguirai l'app di `pub-sub.js` esempio che si trova nella `aws-iot-device-sdk-js-v2/samples/node` directory del Device SDK per. AWS IoT JavaScript Questa app mostra come un dispositivo, la tua istanza Amazon EC2, utilizza la libreria MQTT per pubblicare ed effettuare la sottoscrizione ai messaggi MQTT. L'app di esempio `pub-sub.js` esegue la sottoscrizione a un argomento `topic_1`, pubblica 10 messaggi in tale argomento e visualizza i messaggi ricevuti dal broker di messaggi.
**Per installare ed eseguire l'app di esempio**
1. Nella finestra **Amazon EC2 Instance Connect**, accedi alla directory `aws-iot-device-sdk-js-v2/samples/node/pub_sub` che l'SDK ha creato e installa l'app di esempio utilizzando questi comandi.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. Nella finestra di **Amazon EC2 Instance Connect**, accedi *your-iot-endpoint* AWS IoT utilizzando questo comando.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
1. Nella finestra **Amazon EC2 Instance Connect**, inserisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
node dist/index.js --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
L'applicazione di esempio:
1. Si AWS IoT Core connette al tuo account.
1. Sottoscrive l'argomento del messaggio **topic\$11** e visualizza i messaggi ricevuti su tale argomento.
1. Pubblica 10 messaggi sull’argomento **topic\$11**.
1. L'output sia simile a quello riportato di seguito:
```
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":1}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":2}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":3}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":4}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":5}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":6}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":7}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":8}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":9}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":10}
```
In caso di problemi nell'esecuzione dell'app di esempio, consulta [Risolvi i problemi con l'applicazione di esempio](gs-device-troubleshoot.md).
È inoltre possibile aggiungere il parametro `--verbosity debug` alla riga di comando in modo che l'app di esempio visualizzi messaggi dettagliati su ciò che sta facendo. Tali informazioni potrebbero fornirti l'aiuto necessario per risolvere il problema.
## Visualizza i messaggi dell'app di esempio nella AWS IoT console
È possibile visualizzare i messaggi dell'app di esempio durante il passaggio attraverso il broker di messaggi utilizzando il **client di test MQTT** nella **console AWS IoT **.
**Per visualizzare i messaggi MQTT pubblicati dall'app di esempio**
1. Verificare [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md). In questo modo si impara come utilizzare il **client di test MQTT** nella **console AWS IoT ** per visualizzare i messaggi MQTT durante il passaggio attraverso il broker di messaggi.
1. Apri il **client di test MQTT** nella **console AWS IoT **.
1. In **Subscribe to a topic** (Sottoscrizione a un argomento), effettua la sottoscrizione all'argomento, **topic\$11**.
1. Nella finestra **Amazon EC2 Instance Connect**, esegui nuovamente l'app di esempio e guarda i messaggi nel **client d test MQTT** nella **console AWS IoT **.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
node dist/index.js --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Per ulteriori informazioni su MQTT e su come AWS IoT Core supporta il protocollo, vedere [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).
# Usa il tuo PC o Mac Windows o Linux come dispositivo AWS IoT
In questo tutorial, configurerai un personal computer da utilizzare con AWS IoT. Queste istruzioni supportano Windows, Linux PCs e Mac. Per eseguire questa operazione, è necessario installare alcuni software sul computer. Se non desideri installare software sul computer, puoi provare [Crea un dispositivo virtuale con Amazon EC2](creating-a-virtual-thing.md) che installa tutto il software in una macchina virtuale.
**Topics**
+ [Configurare il tuo personal computer](#gs-pc-prereqs)
+ [Installa Git, Python e AWS IoT Device SDK per Python](#gs-pc-sdk-node)
+ [Configurare la policy ed eseguire l'applicazione di esempio](#gs-pc-python-app-run)
+ [Visualizza i messaggi dell'app di esempio nella AWS IoT console](#gs-pc-view-msg)
+ [Esecuzione dell'esempio Sottoscrizione condivisa in Python](#gs-pc-shared-subscription-example)
## Configurare il tuo personal computer
Per completare questo tutorial, è necessario un PC Windows o Linux o un Mac con connessione a Internet.
Prima di continuare con la fase successiva, assicurati di poter aprire una finestra della riga di comando nel computer. Utilizza **cmd.exe** su un PC Windows. Su un PC Linux o un Mac, usa **Terminal**.
## Installa Git, Python e AWS IoT Device SDK per Python
In questa sezione installerai Python e AWS IoT Device SDK for Python sul tuo computer.
### Installa e usa la versione più recente di Git e di Python
Questa procedura spiega come installare l'ultima versione di Git e Python sul tuo personal computer.
**Per scaricare e installare Git e Python sul tuo computer**
1. Verificare che sia installato Git nel computer. Nella riga di comando, immetti questo comando.
```
git --version
```
Se il comando visualizza la versione Git, Git è installato e puoi continuare con la fase successiva.
Se il comando visualizza un errore, apri [https://git-scm.com/download](https://git-scm.com/download) e installa Git per il tuo computer.
1. Verifica che Python non sia già installato. Inserisci questo comando nella riga di comando.
```
python -V
```
**Nota**
Se questo comando dà un errore: `Python was not found`, potrebbe essere perché il tuo sistema operativo chiama l'eseguibile Python v3.x come `Python3`. In tal caso, sostituisci tutte le istanze di `python` con `python3` e continua il resto di questo tutorial.
Se il comando visualizza la versione Python, Python è già installato. Questo tutorial richiede Python v3.7 o versioni successive.
1. Se Python è installato, puoi ignorare i passaggi rimanenti in questa sezione. Altrimenti, continua.
1. Apri [https://www.python.org/downloads/](https://www.python.org/downloads/) e scarica il programma di installazione per il tuo computer.
1. Se il download non ha avviato automaticamente l'installazione, esegui il programma scaricato per installare Python.
1. Verificare l'installazione di Python.
```
python -V
```
Conferma che il comando visualizzi la versione di Python. Se la versione di Python non viene visualizzata, prova a scaricare e installare nuovamente Python.
### Installa l'SDK AWS IoT del dispositivo per Python
**Per installare AWS IoT Device SDK for Python sul tuo computer**
1. Installa la v2 del AWS IoT Device SDK for Python.
```
python3 -m pip install awsiotsdk
```
1. Clona il repository AWS IoT Device SDK for Python nella directory aws-iot-device-sdk -python-v2 della tua home directory. Questa procedura si riferisce alla directory di base per i file come installi. *home*
La posizione effettiva della *home* directory dipende dal sistema operativo in uso.
------
#### [ Linux/macOS ]
In macOS e Linux, la *home* directory è. `~`
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ Windows ]
In Windows, puoi trovare il percorso della *home* directory eseguendo questo comando nella `cmd` finestra.
```
echo %USERPROFILE%
cd %USERPROFILE%
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
**Nota**
Se utilizzi Windows PowerShell anziché 1**cmd.exe**, utilizza il seguente comando.
```
echo $home
```
Per ulteriori informazioni, consultate il repository [AWS IoT Device SDK for GitHub Python](https://github.com/aws/aws-iot-device-sdk-python-v2).
### Preparazione dell'esecuzione delle applicazioni di esempio
**Per preparare il sistema all'esecuzione dell'applicazione di esempio**
+ Creazione della directory `certs`. Nella directory `certs`, copia i file della chiave privata, del certificato del dispositivo e del certificato CA root salvati quando è stato creato e registrato l'oggetto in [Crea AWS IoT risorse](create-iot-resources.md). I nomi di file di ogni file nella directory di destinazione devono corrispondere a quelli della tabella.
I comandi della sezione successiva presuppongono che i file di chiave e certificato siano memorizzati sul dispositivo, come illustrato in questa tabella.
------
#### [ Linux/macOS ]
Esegui questo comando per creare la sottodirectory `certs` che verrà utilizzata quando si eseguono le applicazioni di esempio.
```
mkdir ~/certs
```
Nella nuova sottodirectory, copia i file nei percorsi dei file di destinazione indicati nella tabella riportata di seguito.
**Nomi dei file dei certificati**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/using-laptop-as-device.html)
Esegui questo comando per elencare i file nella directory `certs` e confrontarli con quelli elencati nella tabella.
```
ls -l ~/certs
```
------
#### [ Windows ]
Esegui questo comando per creare la sottodirectory `certs` che verrà utilizzata quando si eseguono le applicazioni di esempio.
```
mkdir %USERPROFILE%\certs
```
Nella nuova sottodirectory, copia i file nei percorsi dei file di destinazione indicati nella tabella riportata di seguito.
**Nomi dei file dei certificati**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/using-laptop-as-device.html)
Esegui questo comando per elencare i file nella directory `certs` e confrontarli con quelli elencati nella tabella.
```
dir %USERPROFILE%\certs
```
------
## Configurare la policy ed eseguire l'applicazione di esempio
In questa sezione imposterai la policy ed eseguirai lo script di esempio `pubsub.py` trovato nella directory `aws-iot-device-sdk-python-v2/samples` di SDK per dispositivi AWS IoT per Python. Questo script mostra come il dispositivo utilizza la libreria MQTT per pubblicare e effettuare la sottoscrizione ai messaggi MQTT.
L'app di esempio `pubsub.py` sottoscrive un argomento `test/topic`, pubblica 10 messaggi in tale argomento e visualizza i messaggi ricevuti dal broker messaggi.
Per eseguire l'applicazione di esempio `pubsub.py` sono necessarie le seguenti informazioni:
**Valori dei parametri dell'applicazione**
| Parametro | Dove trovare il valore |
| --- | --- |
| your-iot-endpoint | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/using-laptop-as-device.html) |
Il *your-iot-endpoint* valore ha il formato:`endpoint_id-ats.iot.region.amazonaws.com`, ad esempio,. `a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`
Prima di eseguire lo script, assicurati che le policy relative alle informazioni forniscano le autorizzazioni per lo script di esempio per connettersi, sottoscrivere, pubblicare e ricevere.
**Per trovare e rivedere il documento della policy per una risorsa oggetto**
1. Nella [console AWS IoT](https://console.aws.amazon.com//iot/home#/thinghub), nell'elenco **Things (Oggetti)**, trova la risorsa oggetto che rappresenta il tuo dispositivo.
1. Scegli il link di **Name (Nome)** della risorsa oggetto che rappresenta il tuo dispositivo per aprire la pagina **Thing details (Dettagli dell'oggetto)**.
1. Nella pagina **Thing details (Dettagli dell'oggetto)**, nella scheda **Certificates (Certificati)**, scegli il certificato allegato alla risorsa oggetto. Dovrebbe esserci un solo certificato nell'elenco. Se ci sono più certificati, scegli il certificato i cui sono installati i file sul tuo dispositivo e che verrà utilizzato per connetterti ad AWS IoT Core.
Nella pagina dei dettagli del **Certificate (Certificato)**, nella scheda **Policies (Policy)**, scegli la policy allegata al certificato. Dovrebbe essercene solo uno. Se ce n'è più di uno, ripeti il passaggio successivo per assicurarti che almeno una policy conceda l'accesso richiesto.
1. Nella pagina di panoramica **Policy**, trova l'editor JSON e scegli **Edit policy document (Modifica documento della policy)** per rivedere e modificare il documento della policy secondo necessità.
1. Nell'esempio seguente viene visualizzata la policy JSON. Nell'`"Resource"`elemento, sostituisci `region:account` con il tuo Regione AWS e Account AWS in ciascuno dei `Resource` valori.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/test-*"
]
}
]
}
```
------
#### [ Linux/macOS ]
**Per eseguire lo script di esempio su Linux/macOS**
1. Nella finestra a riga di comando passa alla directory `~/aws-iot-device-sdk-python-v2/samples/node/pub_sub` che l'SDK ha creato utilizzando questi comandi.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key
```
------
#### [ Windows ]
**Per eseguire l'applicazione di esempio su un PC Windows**
1. Nella finestra a riga di comando passa alla directory `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` che l'SDK ha creato e installa l'app di esempio utilizzando questi comandi.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key
```
------
Lo script di esempio:
1. Si connette al AWS IoT Core file per il tuo account.
1. Sottoscrive l'argomento del messaggio **test/argomento** e visualizza i messaggi ricevuti su tale argomento.
1. Pubblica 10 messaggi sull'argomento **test/argomento**.
1. L'output sia simile a quello riportato di seguito:
```
Connected!
Subscribing to topic 'test/topic'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'test/topic': Hello World! [1]
Received message from topic 'test/topic': b'"Hello World! [1]"'
Publishing message to topic 'test/topic': Hello World! [2]
Received message from topic 'test/topic': b'"Hello World! [2]"'
Publishing message to topic 'test/topic': Hello World! [3]
Received message from topic 'test/topic': b'"Hello World! [3]"'
Publishing message to topic 'test/topic': Hello World! [4]
Received message from topic 'test/topic': b'"Hello World! [4]"'
Publishing message to topic 'test/topic': Hello World! [5]
Received message from topic 'test/topic': b'"Hello World! [5]"'
Publishing message to topic 'test/topic': Hello World! [6]
Received message from topic 'test/topic': b'"Hello World! [6]"'
Publishing message to topic 'test/topic': Hello World! [7]
Received message from topic 'test/topic': b'"Hello World! [7]"'
Publishing message to topic 'test/topic': Hello World! [8]
Received message from topic 'test/topic': b'"Hello World! [8]"'
Publishing message to topic 'test/topic': Hello World! [9]
Received message from topic 'test/topic': b'"Hello World! [9]"'
Publishing message to topic 'test/topic': Hello World! [10]
Received message from topic 'test/topic': b'"Hello World! [10]"'
10 message(s) received.
Disconnecting...
Disconnected!
```
In caso di problemi nell'esecuzione dell'app di esempio, consulta [Risolvi i problemi con l'applicazione di esempio](gs-device-troubleshoot.md).
È inoltre possibile aggiungere il parametro `--verbosity Debug` alla riga di comando in modo che l'app di esempio visualizzi messaggi dettagliati su ciò che sta facendo. Tali informazioni potrebbero aiutarti a correggere il problema.
## Visualizza i messaggi dell'app di esempio nella AWS IoT console
È possibile visualizzare i messaggi dell'app di esempio durante il passaggio attraverso il broker di messaggi utilizzando il **client di test MQTT** nella **console AWS IoT **.
**Per visualizzare i messaggi MQTT pubblicati dall'app di esempio**
1. Verificare [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md). In questo modo si impara come utilizzare il **client di test MQTT** nella **console AWS IoT ** per visualizzare i messaggi MQTT durante il passaggio attraverso il broker di messaggi.
1. Apri il **client di test MQTT** nella **console AWS IoT **.
1. In **Subscribe to a topic** (Sottoscrizione a un argomento), effettua la sottoscrizione all'argomento, **test/topic**.
1. Nella finestra a riga di comando, esegui di nuovo l'app di esempio e guarda i messaggi nel **Client MQTT** nella **console AWS IoT **.
------
#### [ Linux/macOS ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic test/topic --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
#### [ Windows ]
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
python3 pubsub.py --topic test/topic --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --endpoint your-iot-endpoint
```
------
Per ulteriori informazioni su MQTT e su come AWS IoT Core supporta il protocollo, vedere [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).
## Esecuzione dell'esempio Sottoscrizione condivisa in Python
AWS IoT Core supporta [sottoscrizioni condivise](mqtt.md#mqtt5-shared-subscription) sia per MQTT 3 che per MQTT 5. Sottoscrizioni condivise consentono a più client di condividere una sottoscrizione a un argomento e solo un client riceverà i messaggi pubblicati su tale argomento utilizzando una distribuzione casuale. Per utilizzare Sottoscrizioni condivise, i client effettuano la sottoscrizione al [filtro di argomenti](https://docs.aws.amazon.com//iot/latest/developerguide/topics.html#topicfilters) di una sottoscrizione condivisa: `$share/{ShareName}/{TopicFilter}`.
**Per configurare la policy ed eseguire l'esempio Sottoscrizione condivisa**
1. Per eseguire l'esempio Sottoscrizione condivisa, è necessario impostare la policy dell'oggetto come documentato in [MQTT 5 Shared Subscription](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription).
1. Per eseguire l'esempio Sottoscrizione condivisa, esegui i comandi seguenti.
------
#### [ Linux/macOS ]
**Per eseguire lo script di esempio su Linux/macOS**
1. Nella finestra a riga di comando passa alla directory `~/aws-iot-device-sdk-python-v2/samples` che l'SDK ha creato utilizzando questi comandi.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --group_identifier consumer
```
------
#### [ Windows ]
**Per eseguire l'applicazione di esempio su un PC Windows**
1. Nella finestra a riga di comando passa alla directory `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` che l'SDK ha creato e installa l'app di esempio utilizzando questi comandi.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --group_identifier consumer
```
------
**Nota**
Facoltativamente, puoi specificare un identificatore gruppo in base alle tue esigenze quando esegui l'esempio (ad esempio, `--group_identifier consumer`). Se non viene specificato, `python-sample` è l'identificatore gruppo predefinito.
1. L'aspetto dell'output nella riga di comando può essere simile al seguente:
```
Publisher]: Lifecycle Connection Success
[Publisher]: Connected
Subscriber One]: Lifecycle Connection Success
[Subscriber One]: Connected
Subscriber Two]: Lifecycle Connection Success
[Subscriber Two]: Connected
[Subscriber One]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Subscriber Two]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [1]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [2]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [3]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [4]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [5]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [6]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [7]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [8]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [9]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [10]"'
[Subscriber One]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code: []
[Subscriber Two]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code []
Publisher]: Lifecycle Disconnected
[Publisher]: Lifecycle Stopped
[Publisher]: Fully stopped
Subscriber One]: Lifecycle Disconnected
[Subscriber One]: Lifecycle Stopped
[Subscriber One]: Fully stopped
Subscriber Two]: Lifecycle Disconnected
[Subscriber Two]: Lifecycle Stopped
[Subscriber Two]: Fully stopped
Complete!
```
1. Apri **Client di test MQTT** nella **console AWS IoT **. In **Sottoscrizione a un argomento**, effettua la sottoscrizione all'argomento della Sottoscrizione condivisa, ad esempio: `$share/consumer/test/topic`. Puoi specificare un identificatore gruppo in base alle tue esigenze quando esegui l'esempio (ad esempio, `--group_identifier consumer`). Se non specifichi un identificatore gruppo, il valore predefinito è `python-sample`. Per ulteriori informazioni, consultare [esempio Python MQTT 5 Shared Subscription](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription) e [Sottoscrizioni condivise](mqtt.md#mqtt5-shared-subscription) nella *Guida per gli sviluppatori di AWS IoT Core *.
Nella finestra a riga di comando, esegui nuovamente l'app di esempio e guarda la distribuzione dei messaggi nel **Client di test MQTT** della **Console AWS IoT ** e la riga di comando.
![\[La pagina di output delle sottoscrizioni condivise.\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/images/shared-subscription-output.png)
# Connettere un Raspberry Pi o altro dispositivo
In questa sezione, configureremo un Raspberry Pi da utilizzare con. AWS IoT Se hai un altro dispositivo che desideri collegare, le istruzioni per Raspberry Pi includono riferimenti che possono aiutarti ad adattare queste istruzioni al tuo dispositivo.
Normalmente questo richiede circa 20 minuti, ma può richiedere più tempo se si hanno molti aggiornamenti del software di sistema da installare.
**Topics**
+ [Configurare il dispositivo](#gs-device-prereqs)
+ [Installa gli strumenti e le librerie necessari per AWS IoT Device SDK](#gs-device-sdk-tools)
+ [Installa AWS IoT Device SDK](#gs-device-install-sdk)
+ [Installazione ed esecuzione dell'applicazione di esempio](#gs-device-node-app-run)
+ [Visualizza i messaggi dell'app di esempio nella AWS IoT console](#gs-device-view-msg)
**Importante**
Adattare queste istruzioni ad altri dispositivi e sistemi operativi può essere difficile. Dovrai comprendere abbastanza bene il tuo dispositivo da poter interpretare queste istruzioni e applicarle al tuo dispositivo.
Se riscontri difficoltà durante la configurazione del dispositivo per AWS IoT, potresti provare una delle altre opzioni del dispositivo come alternativa, ad esempio o. [Crea un dispositivo virtuale con Amazon EC2](creating-a-virtual-thing.md) [Usa il tuo PC o Mac Windows o Linux come dispositivo AWS IoT](using-laptop-as-device.md)
## Configurare il dispositivo
L'obiettivo di questo passaggio è raccogliere ciò che è necessario per configurare il dispositivo in modo che possa avviare il sistema operativo (OS), connettersi a Internet e consentire di interagire con esso tramite un'interfaccia a riga di comando.
Per completare questo tutorial, è necessario quanto segue:
+ Un Account AWS. Se non disponi dell'account, effettua la procedura descritta in [Configurare Account AWS](setting-up.md) prima di continuare.
+ Un [modello Raspberry Pi 3 B](https://www.raspberrypi.com/products/) o più recente. Questo potrebbe funzionare su versioni precedenti di Raspberry Pi, ma non sono state testate.
+ [Raspberry Pi OS (32 bit)](https://www.raspberrypi.com/software/operating-systems/) o versione successiva. Ti consigliamo di utilizzare sempre la versione più recente di Raspberry Pi OS. Le versioni precedenti del sistema operativo potrebbero funzionare, ma non sono state testate.
Per eseguire questo esempio, non è necessario installare il desktop con l'interfaccia grafica utente (GUI); tuttavia, se sei nuovo di Raspberry Pi e l'hardware Raspberry Pi lo supporta, l'utilizzo del desktop con la GUI potrebbe essere più semplice.
+ Una WiFi connessione Ethernet o.
+ Tastiera, mouse, monitor, cavi, alimentatori e altro hardware richiesto dal dispositivo.
**Importante**
Prima di continuare con la fase successiva, è necessario che il sistema operativo sia installato, configurato e in esecuzione. Il dispositivo deve essere connesso a Internet e deve essere possibile accedere al dispositivo utilizzando la sua interfaccia da riga di comando. L'accesso della riga di comando può avvenire tramite tastiera, mouse e monitor collegati direttamente o utilizzando un'interfaccia remota del terminale SSH.
Se sul Raspberry Pi è in esecuzione un sistema operativo che dispone di un'interfaccia utente grafica (GUI), apri una finestra di terminale sul dispositivo ed esegui le seguenti istruzioni in tale finestra. In caso contrario, se ci si connette al dispositivo utilizzando un terminale remoto, ad esempio PuTTY, apri un terminale remoto sul dispositivo e utilizzalo.
## Installa gli strumenti e le librerie necessari per AWS IoT Device SDK
Prima di installare il AWS IoT Device SDK e il codice di esempio, assicurati che il sistema sia aggiornato e disponga degli strumenti e delle librerie necessari per installare. SDKs
1.
**Aggiorna il sistema operativo e installa le librerie richieste**
Prima di installare un AWS IoT Device SDK, esegui questi comandi in una finestra di terminale del dispositivo per aggiornare il sistema operativo e installare le librerie richieste.
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install cmake
```
```
sudo apt-get install libssl-dev
```
1.
**Installa Git**
Se nel sistema operativo del tuo dispositivo non è installato Git, devi installarlo per installare AWS IoT Device SDK for JavaScript.
1. Verifica se Git è già installato eseguendo questo comando.
```
git --version
```
1. Se il comando precedente restituisce la versione Git, Git è già installato ed è possibile passare alla fase 3.
1. Se viene visualizzato un errore quando esegui il comando **git**, installa Git eseguendo questo comando.
```
sudo apt-get install git
```
1. Prova di nuovo per vedere se Git è installato eseguendo questo comando.
```
git --version
```
1. Se Git è installato, passa alla sezione successiva. In caso contrario, risolvi e correggi l'errore prima di continuare. Hai bisogno di Git per installare l'SDK AWS IoT del dispositivo. JavaScript
## Installa AWS IoT Device SDK
Installa l'SDK AWS IoT del dispositivo.
------
#### [ Python ]
In questa sezione installerai Python, i suoi strumenti di sviluppo e AWS IoT Device SDK for Python sul tuo dispositivo. Queste istruzioni sono per un Raspberry Pi con il sistema operativo Raspberry Pi più recente. Se disponi di un altro dispositivo o utilizzi un altro sistema operativo, potrebbe essere necessario adattare queste istruzioni per il dispositivo.
1.
**Installa Python e i suoi strumenti di sviluppo**
Il AWS IoT Device SDK for Python richiede l'installazione di Python v3.5 o versione successiva sul tuo Raspberry Pi.
In una finestra di terminale del dispositivo, esegui questi comandi.
1. Esegui questo comando per determinare la versione di Python installata sul dispositivo.
```
python3 --version
```
Se Python è installato, mostrerà la sua versione.
1. Se la versione visualizzata è `Python 3.5` o superiore, puoi passare alla fase 2.
1. Se la versione visualizzata è inferiore a `Python 3.5`, puoi installare la versione corretta eseguendo questo comando.
```
sudo apt install python3
```
1. Esegui questo comando per confermare che la versione corretta di Python è ora installata.
```
python3 --version
```
1.
**Test per pip3**
In una finestra di terminale del dispositivo, esegui questi comandi.
1. Esegui questo comando per vedere se **pip3** è installato.
```
pip3 --version
```
1. Se il comando restituisce un numero di versione, **pip3** è installato e puoi passare alla fase 3.
1. Se il comando precedente restituisce un errore, esegui questo comando per installare **pip3**.
```
sudo apt install python3-pip
```
1. Esegui questo comando per vedere se **pip3** è installato.
```
pip3 --version
```
1.
**Installa l'attuale AWS IoT Device SDK per Python**
Installa AWS IoT Device SDK for Python e scarica le app di esempio sul tuo dispositivo.
Sul dispositivo, esegui questi comandi.
```
cd ~
python3 -m pip install awsiotsdk
```
```
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ JavaScript ]
In questa sezione installerai Node.js, il gestore di pacchetti npm e AWS IoT Device SDK for JavaScript sul tuo dispositivo. Queste istruzioni sono per un Raspberry Pi che esegue il sistema operativo Raspberry Pi. Se disponi di un altro dispositivo o utilizzi un altro sistema operativo, potrebbe essere necessario adattare queste istruzioni per il dispositivo.
1.
**Installare la versione più recente di Node.js**
Il AWS IoT Device SDK for JavaScript richiede l'installazione di Node.js e del gestore di pacchetti npm sul tuo Raspberry Pi.
1. Scarica la versione più recente del repository Node immettendo questo comando.
```
cd ~
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
```
1. Installa Node e npm.
```
sudo apt-get install -y nodejs
```
1. Verifica l'installazione di Node.
```
node -v
```
Verifica che il comando visualizzi la versione di Node. Questo tutorial richiede Node 10.0 o versioni successive. Se la versione di Node non viene visualizzata, prova a scaricare di nuovo il repository di Node.
1. Verifica l'installazione di npm.
```
npm -v
```
Conferma che il comando visualizzi la versione di npm. Se la versione npm non viene visualizzata, provare a installare nuovamente Node e npm.
1. Riavviare il dispositivo.
```
sudo shutdown -r 0
```
Continua dopo il riavvio del dispositivo.
1.
**Installa il Device SDK per AWS IoT JavaScript**
Installa il AWS IoT Device SDK for JavaScript sul tuo Raspberry Pi.
1. Clona il AWS IoT Device SDK for JavaScript repository nella directory della `aws-iot-device-sdk-js-v2` tua directory. *home* Sul Raspberry Pi, la *home* directory è`~/`, che viene utilizzata come *home* directory nei seguenti comandi. Se il dispositivo utilizza un percorso diverso per la *home* directory, è necessario sostituirlo `~/` con il percorso corretto per il dispositivo nei seguenti comandi.
Questi comandi creano la directory `~/aws-iot-device-sdk-js-v2` e copiano il codice SDK in esso.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Passa alla directory `aws-iot-device-sdk-js-v2` creata nella fase precedente ed esegui `npm install` per installare l'SDK. Il comando `npm install` chiama la compilazione della libreria `aws-crt`, operazione che può richiedere alcuni minuti.
```
cd ~/aws-iot-device-sdk-js-v2
npm install
```
------
## Installazione ed esecuzione dell'applicazione di esempio
In questa sezione, installerai ed eseguirai l'app di `pubsub` esempio disponibile nel AWS IoT Device SDK. Questa app mostra come il tuo dispositivo utilizza la libreria MQTT per pubblicare ed effettuare la sottoscrizione ai messaggi MQTT. L'app di esempio sottoscrive un argomento `topic_1`, pubblica 10 messaggi in tale argomento e visualizza i messaggi ricevuti dal broker di messaggi.
**Installazione dei file di certificato**
L'app di esempio richiede i file di certificato che autenticano il dispositivo da installare sul dispositivo.
**Per installare i file di certificato del dispositivo per l'app di esempio**
1. Crea una `certs` sottodirectory nella tua *home* directory eseguendo questi comandi.
```
cd ~
mkdir certs
```
1. Copia nella directory `~/certs` il certificato, la chiave privata e il certificato CA root creato precedentemente in [Crea AWS IoT risorse](create-iot-resources.md).
La modalità di copia dei file di certificato sul dispositivo dipende dal dispositivo e dal sistema operativo e non è descritto qui. Tuttavia, se il dispositivo supporta un'interfaccia utente grafica (GUI) e dispone di un browser Web, è possibile eseguire la procedura descritta in [Crea AWS IoT risorse](create-iot-resources.md) dal browser web del dispositivo per scaricare i file risultanti direttamente sul dispositivo.
I comandi della sezione successiva presuppongono che i file di chiave e certificato siano memorizzati sul dispositivo, come illustrato in questa tabella.
**Nomi dei file dei certificati**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/iot/latest/developerguide/connecting-to-existing-device.html)
Per eseguire l'app di esempio sono necessarie le seguenti informazioni:
**Valori dei parametri dell'applicazione**
| Parametro | Dove trovare il valore |
| --- | --- |
| your-iot-endpoint | Nella [console AWS IoT](https://console.aws.amazon.com/iot/home), scegli **All devices** (Tutti i dispositivi) e quindi **Things** (Oggetti). Nella pagina **Impostazioni** del AWS IoT menu. L'endpoint viene visualizzato nella sezione **Device data endpoint** (Endpoint dei dati del dispositivo). |
Il *your-iot-endpoint* valore ha un formato di:`endpoint_id-ats.iot.region.amazonaws.com`, ad esempio,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`.
------
#### [ Python ]
**Per installare ed eseguire l'app di esempio**
1. Passa alla directory delle app di esempio.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
1. Osserva che l'applicazione di esempio:
1. Si connette al AWS IoT servizio del tuo account.
1. Sottoscrive l'argomento del messaggio **topic\$11** e visualizza i messaggi ricevuti su tale argomento.
1. Pubblica 10 messaggi sull’argomento **topic\$11**.
1. L'output sia simile a quello riportato di seguito:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to topic 'topic_1'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'topic_1': Hello World! [1]
Received message from topic 'topic_1': b'Hello World! [1]'
Publishing message to topic 'topic_1': Hello World! [2]
Received message from topic 'topic_1': b'Hello World! [2]'
Publishing message to topic 'topic_1': Hello World! [3]
Received message from topic 'topic_1': b'Hello World! [3]'
Publishing message to topic 'topic_1': Hello World! [4]
Received message from topic 'topic_1': b'Hello World! [4]'
Publishing message to topic 'topic_1': Hello World! [5]
Received message from topic 'topic_1': b'Hello World! [5]'
Publishing message to topic 'topic_1': Hello World! [6]
Received message from topic 'topic_1': b'Hello World! [6]'
Publishing message to topic 'topic_1': Hello World! [7]
Received message from topic 'topic_1': b'Hello World! [7]'
Publishing message to topic 'topic_1': Hello World! [8]
Received message from topic 'topic_1': b'Hello World! [8]'
Publishing message to topic 'topic_1': Hello World! [9]
Received message from topic 'topic_1': b'Hello World! [9]'
Publishing message to topic 'topic_1': Hello World! [10]
Received message from topic 'topic_1': b'Hello World! [10]'
10 message(s) received.
Disconnecting...
Disconnected!
```
In caso di problemi nell'esecuzione dell'app di esempio, consulta [Risolvi i problemi con l'applicazione di esempio](gs-device-troubleshoot.md).
È inoltre possibile aggiungere il parametro `--verbosity Debug` alla riga di comando in modo che l'app di esempio visualizzi messaggi dettagliati su ciò che sta facendo. Tali informazioni potrebbero fornirti l'aiuto necessario per risolvere il problema.
------
#### [ JavaScript ]
**Per installare ed eseguire l'app di esempio**
1. Nella finestra a riga di comando passa alla directory `~/aws-iot-device-sdk-js-v2/samples/node/pub_sub` che l'SDK ha creato e installa l'app di esempio utilizzando questi comandi. Il comando `npm install` chiama la compilazione della libreria `aws-crt`, operazione che può richiedere alcuni minuti.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. Nella finestra della riga di comando, sostituisci *your-iot-endpoint* come indicato ed esegui questo comando.
```
node dist/index.js --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
1. Osserva che l'applicazione di esempio:
1. Si connette al AWS IoT servizio del tuo account.
1. Sottoscrive l'argomento del messaggio **topic\$11** e visualizza i messaggi ricevuti su tale argomento.
1. Pubblica 10 messaggi sull’argomento **topic\$11**.
1. L'output sia simile a quello riportato di seguito:
```
Publish received on topic topic_1
{"message":"Hello world!","sequence":1}
Publish received on topic topic_1
{"message":"Hello world!","sequence":2}
Publish received on topic topic_1
{"message":"Hello world!","sequence":3}
Publish received on topic topic_1
{"message":"Hello world!","sequence":4}
Publish received on topic topic_1
{"message":"Hello world!","sequence":5}
Publish received on topic topic_1
{"message":"Hello world!","sequence":6}
Publish received on topic topic_1
{"message":"Hello world!","sequence":7}
Publish received on topic topic_1
{"message":"Hello world!","sequence":8}
Publish received on topic topic_1
{"message":"Hello world!","sequence":9}
Publish received on topic topic_1
{"message":"Hello world!","sequence":10}
```
In caso di problemi nell'esecuzione dell'app di esempio, consulta [Risolvi i problemi con l'applicazione di esempio](gs-device-troubleshoot.md).
È inoltre possibile aggiungere il parametro `--verbosity Debug` alla riga di comando in modo che l'app di esempio visualizzi messaggi dettagliati su ciò che sta facendo. Tali informazioni potrebbero fornirti l'aiuto necessario per risolvere il problema.
------
## Visualizza i messaggi dell'app di esempio nella AWS IoT console
È possibile visualizzare i messaggi dell'app di esempio durante il passaggio attraverso il broker di messaggi utilizzando il **client di test MQTT** nella **console AWS IoT **.
**Per visualizzare i messaggi MQTT pubblicati dall'app di esempio**
1. Verificare [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md). In questo modo si impara come utilizzare il **client di test MQTT** nella **console AWS IoT ** per visualizzare i messaggi MQTT durante il passaggio attraverso il broker di messaggi.
1. Apri il **client di test MQTT** nella **console AWS IoT **.
1. Effettua la sottoscrizione all'argomento **topic\$11**.
1. Nella finestra a riga di comando, esegui di nuovo l'app di esempio e guarda i messaggi nel **Client MQTT** nella **console AWS IoT **.
------
#### [ Python ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
#### [ JavaScript ]
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
node dist/index.js --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
# Risolvi i problemi con l'applicazione di esempio
Se si verifica un errore quando tenti di eseguire l'app di esempio, ecco alcune cose da verificare.
## Controlla il certificato
Se il certificato non è attivo, non AWS IoT accetterà alcun tentativo di connessione che lo utilizzi per l'autorizzazione. Quando crei il tuo certificato, potrebbe capitarti di trascurare il bottone **Activate (Attiva)**. Fortunatamente, puoi attivare il certificato dalla [console AWS IoT](https://console.aws.amazon.com/iot/home).
**Per controllare l'attivazione del certificato**
1. Nella [console AWS IoT](https://console.aws.amazon.com/iot/home), nel menu a sinistra, seleziona **Secure (Sicurezza)**, quindi scegli **Certificates (Certificati)**.
1. Nell'elenco dei certificati, individua il certificato creato per l'esercizio e verificane lo stato nella colonna **Status (Stato)**.
Se non ti ricordi il nome del certificato, verifica se sono presenti **Inactive (Inattivo)** per vedere se potrebbero essere quelli che stai usando.
Scegli il certificato nell'elenco per aprire la relativa pagina dei dettagli. Nella pagina dettagli, puoi vedere la **Create date (Creare data)** per informazioni sull'identificazione del certificato.
1. **Per attivare un certificato inattivo** nella pagina dei dettagli del certificato, seleziona **Actions (Operazioni)** e poi **Activate (Attiva)**.
Se hai trovato il certificato corretto e il relativo certificato è attivo, ma si verificano ancora problemi nell'esecuzione dell'app di esempio, verifica la sua policy come descritto nel passaggio successivo.
È inoltre possibile provare a creare un nuovo oggetto e un nuovo certificato seguendo la procedura descritta in [Crea un oggetto](create-iot-resources.md#create-aws-thing). Se crei un nuovo oggetto, dovrai assegnarli un nuovo nome e scaricare i nuovi file del certificato sul tuo dispositivo.
## Controlla la policy collegata al certificato
Le politiche autorizzano le azioni in AWS IoT. Se il certificato utilizzato per la connessione ad AWS IoT non dispone di una policy o non ha una policy che gli consenta di connettersi, la connessione verrà rifiutata, anche se il certificato è attivo.
**Per controllare i criteri collegati a un certificato**
1. Individua il certificato come descritto nell'elemento precedente e apri la relativa pagina dei dettagli.
1. Nel menu a sinistra della pagina dei dettagli del certificato, scegli **Policies** (Policy) per visualizzare le policy collegate al certificato.
1. Se al certificato non sono associate policy, aggiungine una scegliendo il menu **Actions (Operazioni)**, quindi scegli **Attach policy (Collega policy)**.
Scegli la policy che hai creato in precedenza in [Crea AWS IoT risorse](create-iot-resources.md).
1. Se è associata una policy, scegli il riquadro policy per aprire la pagina dei dettagli.
Nella pagina dei dettagli, rivedi **Policy document (Documento di policy)** per assicurarti che contenga le stesse informazioni di quello creato in [Crea una AWS IoT politica](create-iot-resources.md#create-iot-policy).
## Controlla la riga di comando
Assicurati di aver usato la riga di comando corretta per il tuo sistema. I comandi utilizzati sui sistemi Linux e macOS sono spesso diversi da quelli utilizzati nei sistemi Windows.
## Controlla l'indirizzo dell'endpoint
Esamina il comando immesso e ricontrolla l'indirizzo dell'endpoint nel comando con quello nella [console AWS IoT](https://console.aws.amazon.com/iot/home).
## Controlla i nomi dei file del certificato
Confronta i nomi dei file nel comando inserito con i nomi dei file dei certificati nella directory `certs`.
Alcuni sistemi potrebbero richiedere che i nomi dei file siano tra virgolette per funzionare correttamente.
## Controlla l'installazione dell'SDK
Assicurati che l'installazione dell'SDK sia completa e corretta.
In caso di dubbio, reinstalla l'SDK sul dispositivo. Nella maggior parte dei casi, è sufficiente trovare la sezione del tutorial intitolata **Installa l'SDK del AWS IoT dispositivo **SDK language** e seguire nuovamente** la procedura.
Se utilizzi **AWS IoT Device SDK per JavaScript**, ricordati di installare le app di esempio prima di provare a eseguirle. L'installazione dell'SDK non installa automaticamente le app di esempio. Le app di esempio devono essere installate manualmente dopo l'installazione dell'SDK.