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à.

# Pubblicazione HTTPS
<a name="http"></a>

I client possono pubblicare messaggi effettuando richieste all'API REST utilizzando i protocolli HTTP 1.0 o 1.1. Per l'autenticazione e i mapping delle porte utilizzati dalle richieste HTTP, consulta [Protocolli, mappature delle porte e autenticazione](protocols.md#protocol-mapping).

**Nota**  
A differenza di MQTT, HTTPS non supporta un valore `clientId`. `clientId` è disponibile quando si utilizza MQTT, ma non è disponibile quando si utilizza HTTPS.

## URL del messaggio HTTPS
<a name="httpurl"></a>

I dispositivi e i client pubblicano i loro messaggi attraverso richieste POST a un endpoint specifico del client e a un URL specifico dell'argomento:

```
https://IoT_data_endpoint/topics/url_encoded_topic_name?qos=1
```
+  *IoT\$1data\$1endpoint*è l'[endpoint dei dati AWS IoT del dispositivo](iot-connect-devices.md#iot-connect-device-endpoints). È possibile trovare l'endpoint nella AWS IoT console nella pagina dei dettagli dell'oggetto o sul client utilizzando il AWS CLI comando: 

  ```
  aws iot describe-endpoint --endpoint-type iot:Data-ATS
  ```

   L'endpoint dovrebbe assomigliare a questo: `a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com` 
+ *url\$1encoded\$1topic\$1name*è il [nome completo dell'argomento](topics.md#topicnames) del messaggio inviato.

## Esempi di codice di messaggio HTTPS
<a name="codeexample"></a>

Questi sono alcuni esempi di come inviare un messaggio HTTPS a AWS IoT.

------
#### [ Python (port 8443) ]

```
import requests
import argparse

# define command-line parameters
parser = argparse.ArgumentParser(description="Send messages through an HTTPS connection.")
parser.add_argument('--endpoint', required=True, help="Your AWS IoT data custom endpoint, not including a port. " +
                                                      "Ex: \"abcdEXAMPLExyz-ats.iot.us-east-1.amazonaws.com\"")
parser.add_argument('--cert', required=True, help="File path to your client certificate, in PEM format.")
parser.add_argument('--key', required=True, help="File path to your private key, in PEM format.")
parser.add_argument('--topic', required=True, default="test/topic", help="Topic to publish messages to.")
parser.add_argument('--message', default="Hello World!", help="Message to publish. " +
                                                      "Specify empty string to publish nothing.")

# parse and load command-line parameter values
args = parser.parse_args()

# create and format values for HTTPS request
publish_url = 'https://' + args.endpoint + ':8443/topics/' + args.topic + '?qos=1'
publish_msg = args.message.encode('utf-8')

# make request
publish = requests.request('POST',
            publish_url,
            data=publish_msg,
            cert=[args.cert, args.key])

# print results
print("Response status: ", str(publish.status_code))
if publish.status_code == 200:
        print("Response body:", publish.text)
```

------
#### [ Python (port 443) ]

```
import requests
import http.client
import json
import ssl

ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_CLIENT)
ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2

# note the use of ALPN
ssl_context.set_alpn_protocols(["x-amzn-http-ca"])
ssl_context.load_verify_locations(cafile="./<root_certificate>")

# update the certificate and the AWS endpoint
ssl_context.load_cert_chain("./<certificate_in_PEM_Format>", "<private_key_in_PEM_format>")
connection = http.client.HTTPSConnection('<the ats IoT endpoint>', 443, context=ssl_context)
message = {'data': 'Hello, I'm using TLS Client authentication!'}
json_data = json.dumps(message)
connection.request('POST', '/topics/device%2Fmessage?qos=1', json_data)

# make request
response = connection.getresponse()

# print results
print(response.read().decode())
```

------
#### [ CURL ]

Per utilizzare [curl](https://curl.haxx.se) per inviare un messaggio da un client o da un dispositivo a AWS IoT.

**Per usare curl per inviare un messaggio da un dispositivo AWS IoT client**

1. Controlla la versione **curl**.

   1. Sul client, eseguire questo comando al prompt dei comandi.

      **curl --help**

      Nel testo della guida, cercare le opzioni TLS. Viene visualizzata l'opzione `--tlsv1.2`.

   1. Se viene visualizzata l'opzione `--tlsv1.2`, continuare.

   1. Se non visualizzi l'opzione `--tlsv1.2` o ricevi un errore `command not found`, aggiorna o installa curl sul client o installa `openssl` prima di continuare.

1. Installare i certificati sul client.

   Copia i file di certificato che hai creato quando hai registrato il tuo client (cosa) nella AWS IoT console. Assicurarsi di disporre di questi tre file di certificato sul client prima di continuare.
   + Il file del certificato CA (*Amazon-root-CA-1.pem* in questo esempio).
   + File di certificato del client (*device.pem.crt* in questo esempio).
   + Il file della chiave privata del client (*private.pem.key* in questo esempio).

1. Crea la riga di comando **curl**, sostituendo i valori sostituibili per quelli dell'account e del sistema.

   ```
   curl --tlsv1.2 \
       --cacert Amazon-root-CA-1.pem \
       --cert device.pem.crt \
       --key private.pem.key \
       --request POST \
       --data "{ \"message\": \"Hello, world\" }" \
       "https://IoT_data_endpoint:8443/topics/topic?qos=1"
   ```  
--tlsv1.2  
Utilizza TLS 1.2 (SSL).  
--cacert *Amazon-root-CA-1.pem*  
Il nome del file e il percorso, se necessario, del certificato CA per verificare il peer.  
--certificato *device.pem.crt*  
Il nome e il percorso del file del certificato del client, se necessario.  
--chiave *private.pem.key*  
Il nome e il percorso del file della chiave privata del client, se necessario.  
--request POST  
Il tipo di richiesta HTTP (in questo caso POST).  
--dati "» *\$1 \$1"message\$1": \$1"Hello, world\$1" \$1*  
Dati HTTP POST che vuoi pubblicare. In questo caso, è una stringa JSON, con le virgolette interne precedute da un carattere di escape barra rovesciata (\$1).  
«https: *IoT\$1data\$1endpoint* //8443/topics/? *topic* qos=1"  
L'URL dell'endpoint di dati del AWS IoT dispositivo del client, seguito dalla porta HTTPS`:8443`, seguita dalla parola chiave `/topics/` e dal nome dell'argomento, in questo caso. `topic` Specifica la qualità del servizio come parametro di query, `?qos=1`.

1. Apri il client di test MQTT nella AWS IoT console.

   Segui le istruzioni [Visualizza i messaggi MQTT con il AWS IoT client MQTT](view-mqtt-messages.md) e configura la console per sottoscrivere i messaggi con il nome dell'argomento *topic* usato nel **curl** comando oppure usa il filtro wildcard per gli argomenti di. `#`

1. Testare il comando.

   Durante il monitoraggio dell'argomento nel client di test della console AWS IoT , andare al client ed emettere la riga di comando curl creata nel passaggio 3. Nella console vengono visualizzati i messaggi del client.

------