Regístrate para obtener una{" "}
cuenta de Auth0
{" "}
o{" "}
console.log("log in")}>
inicia sesión
{" "}
en tu cuenta existente para integrarte directamente con tu propio tenant.
;
};
export const sections = [{
id: "configure-auth0",
title: "Configurar Auth0"
}, {
id: "install-the-auth0-php-sdk",
title: "Instalar el SDK de Auth0 para PHP"
}, {
id: "listen-for-the-bearer-tokens",
title: "Detectar los tokens de portador"
}, {
id: "create-and-configure-routes",
title: "Crear y configurar rutas"
}, {
id: "configure-endpoint-authorization",
title: "Configurar la autorización del endpoint"
}, {
id: "authorize-with-scopes",
title: "Autorizar con alcances"
}];
Auth0 le permite agregar autorización de endpoints basada en tokens a casi cualquier tipo de aplicación de forma rápida. Esta guía
muestra cómo integrar Auth0, añadir autorización basada en tokens y proteger las rutas de la aplicación mediante el Auth0
PHP SDK.
Para usar este inicio rápido, necesitarás:
Para usar los servicios de Auth0, debe tener una aplicación registrada en el Auth0 Dashboard. En la aplicación de Auth0
configura cómo quiere que funcione la autenticación para su proyecto.
### Configurar una aplicación
Use el selector interactivo para crear una nueva aplicación de Auth0 o seleccionar una aplicación existente que represente
el proyecto que quiere integrar. A cada aplicación de Auth0 se le asigna un ID de cliente alfanumérico único que
el código de su aplicación usa para llamar a las API de Auth0 a través del SDK.
Cualquier configuración que realice con esta guía de inicio rápido se actualizará automáticamente para su aplicación en el [Dashboard](https://manage.auth0.com/#/), donde
podrá administrar sus aplicaciones en el futuro.
Si prefiere explorar una configuración completa, puede ver una aplicación de ejemplo en su lugar.
### Configurar una API
Del mismo modo, debe crear una nueva API de Auth0 o usar una API existente que represente el proyecto que
quiere integrar desde el [Dashboard](https://manage.auth0.com/#/). Elija un identificador único para la API y anótelo. Necesita
ese identificador para configurar su aplicación a continuación.
Auth0 proporciona un [SDK de
PHP](https://github.com/auth0/auth0-PHP) (Auth0-PHP) para simplificar la implementación de la autenticación y la autorización de Auth0 en aplicaciones PHP.
El SDK de PHP de Auth0 requiere [PSR-17](https://www.php-fig.org/psr/psr-17/) y [PSR-18](https://www.php-fig.org/psr/psr-18/) instalados, además de bibliotecas HTTP compatibles para gestionar las solicitudes de red. Si no
dispone de bibliotecas, puede instalar opciones fiables ejecutando los siguientes comandos en la
terminal:
```bash lines theme={null}
cd
composer require symfony/http-client nyholm/psr7
```
Ahora, instala el SDK de PHP de Auth0 ejecutando el siguiente comando en la terminal:
```bash lines theme={null}
composer require auth0/auth0-php
```
### Configurar el SDK de Auth0
Para que el SDK funcione correctamente, debe establecer las siguientes propiedades en el SDK de Auth0 durante la inicialización:
* `strategy`: La estrategia ayuda a definir el comportamiento del SDK según el caso de uso de su aplicación. En este
caso, debe establecer esta propiedad en la constante
`Auth0\SDK\Configuration\SdkConfiguration::STRATEGY_API`
* domain: El dominio de su inquilino de Auth0. Por lo general, lo encontrará en el Auth0 Dashboard, en
Settings de la aplicación, en el campo Domain. Si usa un dominio personalizado, establezca este valor en el de su dominio personalizado
en su lugar.
* clientId: El ID de la aplicación de Auth0 que configuró anteriormente en esta guía de inicio rápido. Puede encontrarlo en el
Auth0 Dashboard, en Settings de su aplicación, en el campo Client ID.
* clientSecret: El secreto de la aplicación de Auth0 que creó anteriormente en esta guía de inicio rápido. El secreto del cliente está en
el Auth0 Dashboard, en Settings de su aplicación, en el campo Client Secret.
* audience: El identificador de la API de Auth0 que registró anteriormente. Debe proporcionarse como un array.
##### Punto de control
Su SDK de Auth0 ya está configurado correctamente. Ejecute su aplicación para verificar que:
* El SDK se inicializa correctamente.
* Su aplicación no genera ningún error relacionado con Auth0.
A continuación, amplíe su aplicación para recuperar y procesar tokens Bearer. Los tokens Bearer son tokens de acceso que los clientes proporcionan a
su API con las solicitudes en nombre de los usuarios. Los tokens de acceso permiten o deniegan el acceso a las rutas de su
aplicación. Esto se conoce como autorización de endpoints.
La forma más sencilla de recuperar tokens de acceso de una solicitud es usar el método `getBearerToken()` del SDK de PHP.
Este método recupera tokens de parámetros GET, cuerpos POST, encabezados de solicitud y otras fuentes. En este
caso, el SDK de PHP procesa los tokens enviados en solicitudes GET en el parámetro `token` o desde el encabezado HTTP
`Authorization`.
Ahora, instala una biblioteca de enrutamiento para dirigir las solicitudes entrantes a tu aplicación. Este paso no es obligatorio,
pero simplifica la estructura de la aplicación para esta guía de inicio rápido.
```bash lines theme={null}
composer require steampixel/simple-php-router
```
Cree un nuevo archivo en su aplicación llamado `router.php` para definir las rutas. Copie el código desde
el panel interactivo de la derecha, en la pestaña **router.php**.
Ahora que ha configurado su aplicación de Auth0, el SDK de PHP de Auth0, y su aplicación recupera tokens Bearer
de las solicitudes, el siguiente paso es configurar la autorización de endpoints para su proyecto. El método
`getBearerToken()` que implementó anteriormente devuelve una instancia de la clase `Token` que incluye
detalles sobre el acceso de la solicitud.
Dado que el método `getBearerToken()` valida y verifica automáticamente la solicitud entrante, su
aplicación determina los detalles del token de acceso evaluando la respuesta del método. Cuando la respuesta es
null, no se ha proporcionado ningún token válido. De lo contrario, inspeccione el contenido de la respuesta para obtener más información sobre la
solicitud.
En el panel interactivo de la derecha, puede ver una comprobación para determinar si la respuesta es null o no y así filtrar el acceso a
su ruta `/api/private`.
En algunos casos, puede que quiera filtrar el acceso a una ruta específica en función de los alcances solicitados en un token de acceso.
Como se muestra en el panel interactivo de la derecha, evalúe el contenido de la propiedad 'scope' de la
respuesta del método `getBearerToken()` para comprobar los alcances otorgados por el token de acceso.
## Próximos pasos
¡Excelente trabajo! Si llegaste hasta aquí, ya deberías tener el inicio de sesión, el cierre de sesión y la información del perfil de usuario funcionando en tu aplicación.
Con esto concluye nuestro tutorial de inicio rápido, pero hay mucho más por explorar. Para saber más sobre lo que puedes hacer con Auth0, consulta:
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Aprenda a configurar y administrar su inquilino de Auth0 y sus aplicaciones
* [Auth0-PHP SDK](https://github.com/auth0/auth0-php) - Explora más a fondo el SDK utilizado en este tutorial
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Descubre las integraciones que puedes habilitar para ampliar las capacidades de Auth0
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// La siguiente ruta es solo para evitar confusión.
// No usamos una 'index route' en esta aplicación, por lo que redirigimos las solicitudes a /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={20-23} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// La siguiente ruta es solo para evitar confusión.
// No usamos una 'index route' en esta aplicación, por lo que redirigimos las solicitudes a /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php router.php lines highlight={} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// La siguiente ruta es solo para evitar confusión.
// No usamos una 'index route' en esta aplicación, por lo que redirigimos las solicitudes a /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={21-31} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// La siguiente ruta es solo para evitar confusiones.
// No usamos una 'index route' en esta aplicación, por lo que redirigimos las solicitudes a /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
```php router.php lines highlight={33-48} theme={null}
'Hello from a public endpoint! You don\'t need to be authenticated to see this.',
'token' => $token
]);
});
Route::add('/api/private', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated to see this.',
'token' => $token,
]);
});
Route::add('/api/private-scoped', function() use ($token) {
if ($token === null) {
http_response_code(401);
exit;
}
if (! in_array('read:messages', $token['scopes'], true)) {
http_response_code(401);
exit;
}
routeResponse([
'message' => 'Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.',
'token' => $token,
]);
});
// La siguiente ruta es solo para evitar confusión.
// No usamos una 'index route' en esta app, por lo que redirigimos las solicitudes a /api/public.
Route::add('/', function() {
header('Location: /api/public');
});
Route::run();
```
```php index.php lines highlight={} theme={null}
getBearerToken(
get: ['token'],
server: ['Authorization']
);
require('router.php');
```
Regístrate para obtener una{" "}
cuenta de Auth0
{" "}
o{" "}
console.log("log in")}>
inicia sesión
{" "}
en tu cuenta existente para integrarte directamente con tu propio tenant.