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: "laravel-installation",
title: "Instalación de Laravel"
}, {
id: "sdk-installation",
title: "Instalación del SDK"
}, {
id: "sdk-configuration",
title: "Configuración del SDK"
}, {
id: "access-control",
title: "Control de acceso"
}, {
id: "token-information",
title: "Información sobre el token"
}, {
id: "retrieve-user-information",
title: "Obtener información del usuario"
}, {
id: "run-the-application",
title: "Ejecutar la aplicación"
}, {
id: "retrieve-a-test-token",
title: "Obtener un token de prueba"
}];
[Auth0's Laravel SDK](https://github.com/auth0/laravel-auth0)
te permite agregar rápidamente autorización basada en tokens y control de acceso a rutas en tu aplicación Laravel. Esta guía
muestra cómo integrar Auth0 con una aplicación [Laravel 9
o 10](https://github.com/auth0/laravel-auth0#support-policy) nueva (o existente).
**Las aplicaciones backend se diferencian de las aplicaciones web tradicionales en que no gestionan la autenticación de usuarios ni cuentan con una interfaz de usuario. Proporcionan una API con la que otras aplicaciones pueden interactuar. Aceptan **[tokens de acceso](https://auth0.com/docs/secure/tokens/access-tokens)** desde
los encabezados **`Authorization`** de las solicitudes para controlar el acceso a las rutas.**
Por lo general, se crean aplicaciones front-end independientes para interactuar con este tipo de backends. Estas pueden ser desde [aplicaciones de página única](https://auth0.com/docs/quickstart/spa) hasta [aplicaciones nativas o móviles](https://auth0.com/docs/quickstart/native) (¡y Auth0 también ofrece SDKs para todas ellas!)
Cuando los usuarios necesitan interactuar con tu aplicación backend, primero se autentican con Auth0 a través de la aplicación
frontend. Luego, la aplicación frontend obtiene un token de acceso de Auth0, que puede utilizar para realizar solicitudes
a tu aplicación backend en nombre del usuario.
Como su nombre indica, los [tokens de
acceso](https://auth0.com/docs/secure/tokens/access-tokens) están diseñados para gestionar el control de acceso (autorización) y no contienen información sobre
el usuario. **Las aplicaciones de backend trabajan exclusivamente con tokens de acceso.** Puedes recuperar información sobre el
usuario que creó el token mediante la [API de
Management](https://auth0.com/docs/api/management/v2), como se mostrará más adelante.
**Si aún no tiene configurada una aplicación de Laravel**, abra una terminal en un directorio adecuado para un nuevo
proyecto y ejecute el siguiente comando:
```bash lines wrap theme={null}
composer create-project --prefer-dist laravel/laravel auth0-laravel-api ^9.0
```
Todos los comandos de esta guía asumen que los ejecuta desde el directorio raíz de su proyecto de Laravel, por lo que
debe ir al directorio del nuevo proyecto con `cd`:
```bash lines theme={null}
cd auth0-laravel-api
```
Ejecute el siguiente comando en el directorio de su proyecto para instalar el [Auth0 Laravel SDK](https://github.com/auth0/laravel-auth0):
```bash lines theme={null}
composer require auth0/login:^7.8 --update-with-all-dependencies
```
Luego, genere un archivo de configuración del SDK para su aplicación:
```bash lines theme={null}
php artisan vendor:publish --tag auth0
```
Ejecute el siguiente comando desde el directorio de su proyecto para descargar la [CLI de Auth0](https://github.com/auth0/auth0-cli):
```bash lines wrap theme={null}
curl -sSfL https://raw.githubusercontent.com/auth0/auth0-cli/main/install.sh | sh -s -- -b .
```
Luego, autentica la CLI con tu cuenta de Auth0 y elige "como usuario" cuando se te indique:
```bash lines theme={null}
./auth0 login
```
A continuación, cree una aplicación nueva con Auth0:
```bash lines theme={null}
./auth0 apps create \
--name "My Laravel Backend" \
--type "regular" \
--auth-method "post" \
--callbacks "http://localhost:8000/callback" \
--logout-urls "http://localhost:8000" \
--reveal-secrets \
--no-input \
--json > .auth0.app.json
```
También debes crear una API nueva:
```bash lines theme={null}
./auth0 apis create \
--name "My Laravel Backend API" \
--identifier "https://github.com/auth0/laravel-auth0" \
--offline-access \
--no-input \
--json > .auth0.api.json
```
Esto genera dos archivos en el directorio de tu proyecto que configuran el SDK.
Como estos archivos contienen credenciales, es importante tratarlos como información confidencial. Debes asegurarte de no
incluirlos en el control de versiones. Si usas Git, debes agregarlos a tu archivo `.gitignore`:
```bash lines theme={null}
echo ".auth0.*.json" >> .gitignore
```
El SDK registra automáticamente su guard de autorización en su aplicación Laravel para usarlo con el
middleware `api`, que Laravel aplica de forma predeterminada a todas las rutas del archivo
`routes/api.php` de su aplicación.
Para que el SDK funcione como se espera sin configuración adicional, **debe definir sus rutas en
el archivo **`routes/api.php`**.**
Puede usar el guard de autorización del SDK de Auth0 para restringir el acceso a las rutas de su aplicación.
Para rechazar solicitudes que no contengan un token de acceso válido en el encabezado `Authorization`, puede usar
el middleware `auth` de Laravel:
```php lines theme={null}
Route::get('/private', function () {
return response()->json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
```
También puede exigir que el token proporcionado tenga [permisos](https://auth0.com/docs/manage-users/access-control/rbac) específicos al combinar esto
con el middleware `can` de Laravel:
```php lines theme={null}
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the read:messages permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
```
La información sobre el token de acceso proporcionado puede obtenerse mediante la fachada `Auth` de Laravel o la
función auxiliar `auth()`.
Por ejemplo, para obtener el identificador y la dirección de correo electrónico del usuario:
```php lines theme={null}
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
```
Puede obtener información sobre el usuario que creó el token de acceso desde Auth0 mediante la [Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md). El SDK proporciona un contenedor práctico para esta API,
accesible mediante el método `management()` del SDK.
**Antes de realizar llamadas a la Management API, debe habilitar su aplicación para que se comunique con la
Management API.** Esto puede hacerse desde la [página API del Auth0 Dashboard](https://manage.auth0.com/#/apis/), eligiendo `Auth0 Management API` y
seleccionando la pestaña 'Aplicaciones de máquina a máquina'. Autorice su aplicación de Laravel y, a continuación, haga clic en la flecha
desplegable para elegir los alcances que desea conceder.
Para el siguiente ejemplo, debe conceder el alcance `read:users`. Puede encontrar una lista de endpoints de API y los
alcances requeridos en [la documentación de la Management
API](https://auth0.com/docs/api/management/v2).
```php lines theme={null}
use Auth0\Laravel\Facade\Auth0;
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
**Debe almacenar en caché la información del usuario en su aplicación solo durante períodos breves.** Esto reduce la cantidad
de solicitudes que su aplicación realiza a Auth0 y mejora el rendimiento. Debe evitar almacenar información del usuario
en su aplicación durante períodos prolongados, ya que esto puede dar lugar a datos desactualizados. También debe evitar
almacenar en bases de datos persistentes información del usuario que exceda su identificador.
Ahora ya puede iniciar su aplicación Laravel para que pueda aceptar solicitudes:
```bash lines theme={null}
php artisan serve
```
Puede obtener más información sobre [cómo obtener tokens de acceso aquí](https://auth0.com/docs/secure/tokens/access-tokens/get-access-tokens). Sin embargo, para esta guía de inicio rápido, puede simplemente usar un token de acceso
de [la vista de "prueba" en la configuración de su API](https://manage.auth0.com/#/apis).
La ruta `/me` que creamos anteriormente no funcionará con un token de prueba, ya que no hay ningún usuario real
asociado.
##### Punto de control
Abra una shell e intente enviar solicitudes a su aplicación.
Comience solicitando la ruta pública:
`curl --request GET \ --url http://localhost:8000/api \ --header 'Accept: application/json'`
A continuación, use su token de acceso en un encabezado `Authorization` para solicitar una ruta protegida:
`curl --request GET \ --url http://localhost:8000/api/private \ --header 'Accept: application/json' \ --header 'Authorization: Bearer YOUR_ACCESS_TOKEN'`
Por último, intente solicitar la ruta protegida por scope, que solo funcionará si al token de acceso se le ha concedido el
scope `read:messages`:
`curl --request GET \ --url http://localhost:8000/api/scope \ --header 'Accept: application/json' \ --header 'Authorization: Bearer YOUR_ACCESS_TOKEN'`
### Lectura adicional
* [Repositorios y modelos de usuario](https://github.com/auth0/laravel-auth0/blob/main/docs/Users.md) amplía el SDK de Auth0 para Laravel para usar modelos de usuario
personalizados, y explica cómo almacenar y recuperar usuarios de una base de datos.
* [Conexión de eventos](https://github.com/auth0/laravel-auth0/blob/main/docs/Events.md) explica cómo escuchar los eventos generados por el SDK de Auth0 para Laravel
para personalizar por completo el comportamiento de su integración.
* La compatibilidad con [Management API](https://github.com/auth0/laravel-auth0/blob/main/docs/Management.md) está integrada en el SDK de Auth0 para Laravel, lo que le permite
interactuar con la Management API desde su aplicación Laravel.
## 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 y sus aplicaciones de Auth0
* [SDK laravel-auth0](https://github.com/auth0/laravel-auth0) - Explora más a fondo el SDK utilizado en este tutorial
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Descubra las integraciones que puede habilitar para ampliar la funcionalidad de Auth0
```php routes/api.php lines highlight={6-16} theme={null}
json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the `read:messages` permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
```php routes/api.php lines highlight={18-30} theme={null}
json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the `read:messages` permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
```php routes/api.php lines highlight={32-51} theme={null}
json([
'message' => 'Your token is valid; you are authorized.',
]);
})->middleware('auth');
Route::get('/scope', function () {
return response()->json([
'message' => 'Your token is valid and has the `read:messages` permission; you are authorized.',
]);
})->middleware('auth')->can('read:messages');
Route::get('/', function () {
if (! auth()->check()) {
return response()->json([
'message' => 'You did not provide a valid token.',
]);
}
return response()->json([
'message' => 'Your token is valid; you are authorized.',
'id' => auth()->id(),
'token' => auth()?->user()?->getAttributes(),
]);
});
Route::get('/me', function () {
$user = auth()->id();
$profile = cache()->get($user);
if (null === $profile) {
$endpoint = Auth0::management()->users();
$profile = $endpoint->get($user);
$profile = Auth0::json($profile);
cache()->put($user, $profile, 120);
}
$name = $profile['name'] ?? 'Unknown';
$email = $profile['email'] ?? 'Unknown';
return response()->json([
'name' => $name,
'email' => $email,
]);
})->middleware('auth');
```
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.