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: "define-permissions",
title: "Definir permisos"
}, {
id: "configure-django-to-use-auth0",
title: "Configurar Django para usar Auth0"
}, {
id: "create-the-jwt-validator",
title: "Crear el validador JWT"
}, {
id: "create-the-api-views",
title: "Crear las vistas de la API"
}, {
id: "add-url-mappings",
title: "Agregar las asignaciones de URL"
}];
Esta guía muestra cómo integrar Auth0 con cualquier API de Python nueva o existente desarrollada con [Django](https://www.djangoproject.com/).
Si aún no has creado una API en tu Auth0 Dashboard, puedes usar el selector interactivo para crear una nueva
API de Auth0 o seleccionar una API existente que represente el proyecto con el que deseas integrarte.
También puede consultar nuestra guía de introducción,
que le ayudará a configurar su primera API desde el Auth0 Dashboard.
Cada API en Auth0 se configura con un identificador de API que el código de tu aplicación usará como Audiencia para
validar el Token de acceso.
**¿No conoces Auth0?** Aprende cómo funciona Auth0 y
lee sobre cómo implementar la autenticación y
autorización de API con OAuth 2.0.
Los permisos le permiten definir cómo se puede acceder a los recursos en nombre del usuario con un token de acceso determinado. Por
ejemplo, puede optar por conceder acceso de lectura al recurso `messages` si los usuarios tienen el nivel de acceso de gerente,
y acceso de escritura a ese recurso si tienen el nivel de acceso de administrador.
Puede definir los permisos permitidos en la vista **Permissions** de la sección [APIs](https://manage.auth0.com/#/apis) de Auth0 Dashboard. El siguiente
ejemplo usa el scope `read:messages`.
### Instale las dependencias
1. Añada las siguientes dependencias a su `requirements.txt`:
2. Ejecute `pip install -r requirements.txt`
### Cree una aplicación de Django
Usará una biblioteca llamada [Authlib](https://github.com/lepture/authlib) para crear un [ResourceProtector](https://docs.authlib.org/en/latest/flask/1/resource-server.html), que es un tipo de [decorador de vistas de Django](https://docs.djangoproject.com/en/4.0/topics/http/decorators/) que protege sus recursos (vistas de API) con un
validador determinado.
El validador verificará el Token de acceso que pase al recurso comprobando que tenga una
firma y claims válidos.
Puede usar el validador `JWTBearerTokenValidator` de AuthLib con algunos ajustes para asegurarse de que cumpla
nuestros requisitos para [validar Tokens de acceso](https://auth0.com/docs/secure/tokens/access-tokens/validate-access-tokens).
Para crear su `Auth0JWTBearerTokenValidator`, debe pasarle su `domain` y
`audience` (identificador de la API). Después, obtendrá la clave pública necesaria para verificar la firma del token
y la pasará a la clase `JWTBearerTokenValidator`.
Luego sobrescribirá `claims_options` de la clase para asegurarse de que los claims `expiry`,
`audience` e `issue` del token se validen de acuerdo con nuestros requisitos.
Cree el archivo `apiexample/validator.py` con el código del panel interactivo.
A continuación, crearás tres vistas de API en `apiexample/views.py`:
* `/api/public`: Un endpoint público que no requiere autenticación.
* `/api/private`: Un endpoint privado que requiere un JWT válido de Token de acceso.
* `/api/private-scoped`: Un endpoint privado que requiere un JWT válido de Token de acceso que contenga el
`scope` indicado.
Las rutas protegidas tendrán un decorador `require_auth`, que es un `ResourceProtector`
que usa el `Auth0JWTBearerTokenValidator` que creaste anteriormente.
Para crear el `Auth0JWTBearerTokenValidator`, le pasarás el dominio de tu inquilino y el
identificador de la API que creaste anteriormente.
El decorador `require_auth` en la ruta `private_scoped` acepta un argumento adicional
`"read:messages"`, que comprueba en el Token de acceso el permiso (scope) que creaste anteriormente.
En los pasos anteriores, agregaste métodos al archivo `views.py`. A continuación, asigna esos métodos a URLs mediante el [URL dispatcher](https://docs.djangoproject.com/en/4.0/topics/http/urls/) de Django, que te permite mapear patrones de URL a vistas.
Agrega los patrones de URL a tu archivo `apiexample/urls.py`.
### Realizar una llamada a tu API
Para realizar llamadas a tu API, necesitarás un token de acceso. Puedes obtener un token de acceso para fines de prueba
desde la vista **Test** en tu [configuración de API](https://manage.auth0.com/#/apis).
Proporciona el token de acceso como encabezado `Authorization` en tus solicitudes.
```bash cURL lines theme={null}
curl --request get \
--url 'http:///%7ByourDomain%7D.com/api_path' \
--header 'authorization: Bearer YOUR_ACCESS_TOKEN_HERE'
```
```csharp C# lines theme={null}
var client = new RestClient("http:///%7ByourDomain%7D.com/api_path");
var request = new RestRequest(Method.GET);
request.AddHeader("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE");
IRestResponse response = client.Execute(request);
```
```go Go lines theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "http:///%7ByourDomain%7D.com/api_path"
req, _ := http.NewRequest("get", url, nil)
req.Header.Add("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines theme={null}
HttpResponse response = Unirest.get("http:///%7ByourDomain%7D.com/api_path")
.header("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE")
.asString();
```
```javascript Node.JS lines theme={null}
var axios = require("axios").default;
var options = {
method: 'get',
url: 'http:///%7ByourDomain%7D.com/api_path',
headers: {authorization: 'Bearer YOUR_ACCESS_TOKEN_HERE'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```objc Obj-C lines theme={null}
#import
NSDictionary *headers = @{ @"authorization": @"Bearer YOUR_ACCESS_TOKEN_HERE" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http:///%7ByourDomain%7D.com/api_path"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"get"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume];
```
```php PHP lines theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "http:///%7ByourDomain%7D.com/api_path",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "get",
CURLOPT_HTTPHEADER => [
"authorization: Bearer YOUR_ACCESS_TOKEN_HERE"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines theme={null}
import http.client
conn = http.client.HTTPConnection("")
headers = { 'authorization': "Bearer YOUR_ACCESS_TOKEN_HERE" }
conn.request("get", "/{yourDomain}.com/api_path", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby lines theme={null}
require 'uri'
require 'net/http'
url = URI("http:///%7ByourDomain%7D.com/api_path")
http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Get.new(url)
request["authorization"] = 'Bearer YOUR_ACCESS_TOKEN_HERE'
response = http.request(request)
puts response.read_body
```
```swift Swift lines theme={null}
import Foundation
let headers = ["authorization": "Bearer YOUR_ACCESS_TOKEN_HERE"]
let request = NSMutableURLRequest(url: NSURL(string: "http:///%7ByourDomain%7D.com/api_path")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "get"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
```
## 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 Marketplace](https://marketplace.auth0.com/) - Descubra las integraciones que puede habilitar para ampliar las capacidades de Auth0
```py apiexample/views.py lines highlight={} theme={null}
from authlib.integrations.django_oauth2 import ResourceProtector
from django.http import JsonResponse
from . import validator
require_auth = ResourceProtector()
validator = validator.Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
def public(request):
"""No access token required to access this route
"""
response = "Hello from a public endpoint! You don't need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth(None)
def private(request):
"""A valid access token is required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth("read:messages")
def private_scoped(request):
"""A valid access token and an appropriate scope are required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
return JsonResponse(dict(message=response))
```
```py apiexample/validator.py lines highlight={} theme={null}
import json
from urllib.request import urlopen
from authlib.oauth2.rfc7523 import JWTBearerTokenValidator
from authlib.jose.rfc7517.jwk import JsonWebKey
class Auth0JWTBearerTokenValidator(JWTBearerTokenValidator):
def __init__(self, domain, audience):
issuer = f"https://{domain}/"
jsonurl = urlopen(f"{issuer}.well-known/jwks.json")
public_key = JsonWebKey.import_key_set(
json.loads(jsonurl.read())
)
super(Auth0JWTBearerTokenValidator, self).__init__(
public_key
)
self.claims_options = {
"exp": {"essential": True},
"aud": {"essential": True, "value": audience},
"iss": {"essential": True, "value": issuer},
}
```
```py apiexample/urls.py lines highlight={8-10} theme={null}
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('api/public', views.public),
path('api/private', views.private),
path('api/private-scoped', views.private_scoped)
]
```
```py apiexample/validator.py lines highlight={} theme={null}
import json
from urllib.request import urlopen
from authlib.oauth2.rfc7523 import JWTBearerTokenValidator
from authlib.jose.rfc7517.jwk import JsonWebKey
class Auth0JWTBearerTokenValidator(JWTBearerTokenValidator):
def __init__(self, domain, audience):
issuer = f"https://{domain}/"
jsonurl = urlopen(f"{issuer}.well-known/jwks.json")
public_key = JsonWebKey.import_key_set(
json.loads(jsonurl.read())
)
super(Auth0JWTBearerTokenValidator, self).__init__(
public_key
)
self.claims_options = {
"exp": {"essential": True},
"aud": {"essential": True, "value": audience},
"iss": {"essential": True, "value": issuer},
}
```
```py apiexample/views.py lines highlight={} theme={null}
from authlib.integrations.django_oauth2 import ResourceProtector
from django.http import JsonResponse
from . import validator
require_auth = ResourceProtector()
validator = validator.Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
def public(request):
"""No access token required to access this route
"""
response = "Hello from a public endpoint! You don't need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth(None)
def private(request):
"""A valid access token is required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth("read:messages")
def private_scoped(request):
"""A valid access token and an appropriate scope are required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
return JsonResponse(dict(message=response))
```
```py apiexample/urls.py lines highlight={8-10} theme={null}
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('api/public', views.public),
path('api/private', views.private),
path('api/private-scoped', views.private_scoped)
]
```
```py apiexample/urls.py lines highlight={8-10} theme={null}
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('api/public', views.public),
path('api/private', views.private),
path('api/private-scoped', views.private_scoped)
]
```
```py apiexample/validator.py lines highlight={} theme={null}
import json
from urllib.request import urlopen
from authlib.oauth2.rfc7523 import JWTBearerTokenValidator
from authlib.jose.rfc7517.jwk import JsonWebKey
class Auth0JWTBearerTokenValidator(JWTBearerTokenValidator):
def __init__(self, domain, audience):
issuer = f"https://{domain}/"
jsonurl = urlopen(f"{issuer}.well-known/jwks.json")
public_key = JsonWebKey.import_key_set(
json.loads(jsonurl.read())
)
super(Auth0JWTBearerTokenValidator, self).__init__(
public_key
)
self.claims_options = {
"exp": {"essential": True},
"aud": {"essential": True, "value": audience},
"iss": {"essential": True, "value": issuer},
}
```
```py apiexample/views.py lines highlight={} theme={null}
from authlib.integrations.django_oauth2 import ResourceProtector
from django.http import JsonResponse
from . import validator
require_auth = ResourceProtector()
validator = validator.Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
def public(request):
"""No access token required to access this route
"""
response = "Hello from a public endpoint! You don't need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth(None)
def private(request):
"""A valid access token is required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth("read:messages")
def private_scoped(request):
"""A valid access token and an appropriate scope are required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
return JsonResponse(dict(message=response))
```
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.
Proporciona el token de acceso como encabezado `Authorization` en tus solicitudes.