> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Implementación de la aplicación para el escenario de arquitectura Servidor + API

# Implementación de la aplicación (Aplicaciones de servidor + API)

En esta sección del tutorial, profundizaremos en nuestra API y en la aplicación Machine-to-Machine asociada. Para comenzar desde el principio, lee [Aplicaciones de servidor con API](/es/docs/get-started/architecture-scenarios/server-application-api).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Para simplificar, mantendremos nuestra implementación centrada únicamente en la autenticación y la autorización. Como verás en los ejemplos, la entrada del registro de horas estará codificada de forma fija y la API no la conservará. En su lugar, se limitará a devolver parte de la información.
</Callout>

<div id="define-the-api-endpoints">
  ## Defina los endpoints de la API
</div>

Un **endpoint de API** es un URI estático que representa un recurso (colección de datos).

Por ejemplo, una API de restaurante podría tener endpoints como `/orders` y `/customers`. Una aplicación que se conecta a esta API puede realizar operaciones CRUD (crear, leer, actualizar y eliminar) al llamar a un endpoint de API con el método HTTP asociado (`POST`, `GET`, `PUT`, `PATCH` o `DELETE`).

Para la API de registros de horas de ExampleCo, deberá configurar un endpoint para crear registros de horas.

| Método HTTP | endpoint de API      | Descripción                     |
| ----------- | -------------------- | ------------------------------- |
| `POST`      | `/timesheets/upload` | Crea un nuevo registro de horas |

```json lines theme={null}
{
  'user_id': '007',
  'date': '2017-05-10T17:40:20.095Z',
  'project': 'StoreZero',
  'hours': 5
}
```

Si la API procesa la solicitud correctamente, envía una respuesta con el código de estado `HTTP 201 Created` y un cuerpo que contiene un objeto JSON con una propiedad `message` que describe el registro de horas recién creado:

```json lines theme={null}
{
"message": "Created timesheet 14 for employee 007."
}
```

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Consulta la implementación en [Node.js](/es/docs/get-started/architecture-scenarios/server-application-api/api-implementation-nodejs#1-define-the-api-endpoint).
</Callout>

<div id="secure-the-api-endpoints">
  ### Protege los endpoints de la API
</div>

Para proteger los endpoint(s) de tu API, debes implementar una función de middleware en tu aplicación de API para gestionar los tokens. Esta función comprueba si se incluyó un token en la solicitud a la API, valida el token y luego confirma si se incluyen los alcances necesarios para realizar la acción solicitada.

Si se cumplen todos los criterios, la aplicación de API responde con el mensaje mencionado anteriormente. Si hay algún problema con el <Tooltip tip="Token de acceso: credencial de autorización, en forma de una cadena opaca o de un JWT, que se usa para acceder a una API." cta="Ver glosario" href="/es/docs/glossary?term=access+token">token de acceso</Tooltip> proporcionado (o no se proporciona en absoluto), la aplicación de API envía una respuesta con el código de estado `HTTP 401 Unauthorized`.

**Consulta la implementación en** [**Node.js**](/es/docs/get-started/architecture-scenarios/server-application-api/api-implementation-nodejs#2-secure-the-api-endpoint)**.**

<div id="get-an-access-token">
  #### Obtener un token de acceso
</div>

Para obtener un token de acceso sin usar la implementación de ejemplo de nuestra aplicación, llama al endpoint [Get Token](https://auth0.com/docs/api/authentication#get-token54) de la API de autenticación de Auth0 con la siguiente carga útil:

```json lines theme={null}
{
  audience: "{yourApiIdentifier}",
  grant_type: "client_credentials",
  client_id: "${account.client_id}",
  client_secret: "${account.client_secret}"
}
```

<div id="check-the-application-permissions">
  ## Compruebe los permisos de la aplicación
</div>

Ahora hemos protegido el endpoint de nuestra API con un token de acceso, pero aún no nos hemos asegurado de que el proceso que llama a la API tenga los permisos necesarios para publicar una nueva entrada de registro de horas.

Como se explicó antes, cada token de acceso puede incluir una lista de los permisos que se han concedido a la aplicación. Estos permisos se definen mediante el parámetro de solicitud `scope`. Para obtener más información sobre cómo configurarlos, consulte el apartado [Configurar los alcances](/es/docs/get-started/architecture-scenarios/server-application-api/part-3#configure-the-scopes).

Para nuestro endpoint, requeriremos el alcance `batch:upload`.

**Consulte la implementación en** [**Node.js**](/es/docs/get-started/architecture-scenarios/server-application-api/api-implementation-nodejs#3-check-the-client-permissions)**.**

<div id="implement-the-machine-to-machine-application">
  ### Implementa la aplicación Machine-to-Machine
</div>

En esta sección, veremos cómo implementar una aplicación Machine-to-Machine en nuestro caso.

### Obtener un token de acceso

Comenzaremos invocando el endpoint de la API `/oauth/token` de Auth0 para obtener un token de acceso.

Para ello, necesitaremos los siguientes valores de configuración, que puede encontrar en la [configuración de la aplicación](https://manage.auth0.com/#/applications):

* **Dominio**: el dominio de Auth0 y también el identificador de su inquilino. Este valor formará parte de la URL de la API: `https://{yourTenant}/oauth/token`.
* **<Tooltip tip="Audiencia: identificador único de la audiencia de un token emitido. En un token, se denomina aud; su valor contiene el ID de una aplicación (ID de cliente) para un ID Token o de una API (identificador de la API) para un Token de acceso." cta="Ver glosario" href="/es/docs/glossary?term=Audience">Audiencia</Tooltip>**: identificador de la API.
* **<Tooltip tip="ID de cliente: valor de identificación asignado por Auth0 a su recurso registrado." cta="Ver glosario" href="/es/docs/glossary?term=Client+ID">ID de cliente</Tooltip>**: ID de cliente de la aplicación de Auth0.
* **<Tooltip tip="Secreto del cliente: secreto que usa un cliente (aplicación) para autenticarse con el Servidor de autorización; solo deben conocerlo el cliente y el Servidor de autorización, y debe ser lo suficientemente aleatorio como para que no se pueda adivinar." cta="Ver glosario" href="/es/docs/glossary?term=Client+Secret">Secreto del cliente</Tooltip>**: Secreto del cliente de la aplicación de Auth0.

Nuestra implementación debe realizar una operación `POST` en el endpoint `https://{yourDomain}/oauth/token` con una carga útil en el siguiente formato:

```json lines theme={null}
{
  "audience": "{yourApiIdentifier}",
  "grant_type": "client_credentials",
  "client_id": "${account.client_id}",
  "client_secret": "${account.client_secret}"
}
```

Para obtener más información, consulte [Cómo llamar a su API mediante el flujo de credenciales del cliente](/es/docs/get-started/authentication-and-authorization-flow/client-credentials-flow/call-your-api-using-the-client-credentials-flow).

**Consulte la implementación en** [**Python**](/es/docs/get-started/architecture-scenarios/server-application-api/cron-implementation-python#get-an-access-token).

<div id="invoke-the-api">
  ## Invocar la API
</div>

Ahora que tenemos un token de acceso que incluye los alcances válidos, podemos invocar nuestra API.

Para ello, haremos lo siguiente:

* Crear una entrada de registro de horas codificada manualmente en formato JSON.
* Agregar el token de acceso a la solicitud como encabezado `Authorization`.
* Realizar la solicitud HTTP `POST`.
* Analizar la respuesta e imprimirla en la terminal (opcional).

**Consulte la implementación en** [**Python**](/es/docs/get-started/architecture-scenarios/server-application-api/cron-implementation-python#invoke-the-api).