Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Publicación en HTTPS
<a name="http"></a>

Los clientes pueden publicar mensajes realizando solicitudes a la API REST utilizando los protocolos HTTP 1.0 o 1.1. Para obtener información sobre la autenticación y las asignaciones de puertos utilizados por las solicitudes HTTP, consulte [Protocolos, asignaciones de puertos y autenticación](protocols.md#protocol-mapping).

**nota**  
HTTPS no admite un valor `clientId` como lo hace MQTT. `clientId` está disponible cuando se usa MQTT, pero no cuando se usa HTTPS.

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

Los dispositivos y los clientes publican sus mensajes con solicitudes POST a un punto de conexión específico del cliente y a una dirección URL específica del tema:

```
https://IoT_data_endpoint/topics/url_encoded_topic_name?qos=1
```
+  *IoT\$1data\$1endpoint*es el [punto final de los datos del AWS IoT dispositivo](iot-connect-devices.md#iot-connect-device-endpoints). Puedes encontrar el punto final en la AWS IoT consola, en la página de detalles del dispositivo, o en el cliente mediante el AWS CLI comando: 

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

   El punto de conexión debería tener un aspecto similar al siguiente: `a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com` 
+ *url\$1encoded\$1topic\$1name*es el [nombre completo del tema](topics.md#topicnames) del mensaje que se envía.

## Ejemplos de código de mensajes HTTPS
<a name="codeexample"></a>

Estos son algunos ejemplos de cómo enviar un mensaje 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 ]

Puede usar [curl](https://curl.haxx.se) desde un cliente o dispositivo para enviar un mensaje a AWS IoT.

**Para usar curl para enviar un mensaje desde un dispositivo AWS IoT cliente**

1. Compruebe la versión de **curl**.

   1. En su cliente, ejecute este comando en un símbolo del sistema.

      **curl --help**

      En el texto de ayuda, busque las opciones TLS. Debería ver la opción `--tlsv1.2`.

   1. Si ve la opción `--tlsv1.2`, continúe.

   1. Si no ve la opción `--tlsv1.2` o aparece un error `command not found`, tal vez deba actualizar o instalar curl en el cliente o instalar `openssl` antes de continuar.

1. Instale los certificados en su cliente.

   Copie los archivos de certificado que creó al registrar su cliente (cosa) en la AWS IoT consola. Asegúrese de que tiene estos tres archivos de certificado en su cliente antes de continuar.
   + El archivo de certificado de entidad de certificación (*Amazon-root-CA-1.pem* en este ejemplo).
   + El archivo de certificado del cliente (*device.pem.crt* en este ejemplo).
   + El archivo de clave privada del cliente (*private.pem.key* en este ejemplo).

1. Cree la línea de comandos de **curl** y sustituya los valores reemplazables por los de su cuenta y 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  
Use TLS 1.2 (SSL).  
--cacert *Amazon-root-CA-1.pem*  
El nombre de archivo y la ruta de acceso, si es necesario, del certificado de entidad de certificación para verificar el par.  
--cert *device.pem.crt*  
El nombre y la ruta de acceso del archivo de certificado del cliente, si es necesario.  
--clave *private.pem.key*  
El nombre y la ruta del archivo de la clave privada del cliente, si es necesario.  
--request POST  
El tipo de solicitud HTTP (en este caso, POST).  
--datos «» *\$1 \$1"message\$1": \$1"Hello, world\$1" \$1*  
Los datos de HTTP POST que quiere publicar. En este caso, es una cadena JSON, con las comillas internas con el carácter de escape de barra invertida (\$1).  
«https: //:8443/temas/? *IoT\$1data\$1endpoint* *topic* qos=1"  
La URL del punto de conexión de datos del AWS IoT dispositivo de su cliente, seguida del puerto HTTPS`:8443`, seguido de la palabra clave `/topics/` y, en este caso, `topic` del nombre del tema. Especifique la calidad del servicio como parámetro de consulta, `?qos=1`.

1. Abra el cliente de pruebas de MQTT en la AWS IoT consola.

   Siga las instrucciones [Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md) y configure la consola para suscribirse a los mensajes con el nombre del tema *topic* utilizado en su **curl** comando, o utilice el filtro de temas comodín de. `#`

1. Pruebe el comando.

   Mientras monitoriza el tema en el cliente de prueba de la consola de AWS IoT , vaya a su cliente y ejecute la línea de comandos curl que creó en el paso 3. Debería ver los mensajes de su cliente en la consola.

------