Estratégias de Autenticação e Autorização
Proteja seus endpoints de API usando métodos comuns de autenticação, como JWT, e implemente regras de autorização.
Estratégias de Autenticação e Autorização é uma aula grátis de Elixir & Phoenix: Scalable Backend Development no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Elixir & Phoenix: Scalable Backend Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
Securing Your API Endpoints
When building APIs with Phoenix, securing your endpoints is paramount. This ensures only authorized users can access specific resources and perform actions.
We'll explore two key aspects: Authentication (proving who you are) and Authorization (determining what you can do).
What is Authentication?
Authentication is the process of verifying a user's identity. It's how your API confirms that the person or application making a request is who they claim to be.
- Common methods include username/password, API keys, or tokens.
- Once authenticated, the user's identity is known to the system.
Token-Based Authentication
For APIs, sending username/password with every request is inefficient and insecure. Token-based authentication is a popular solution.
After initial login, the server issues a unique token. The client then sends this token with subsequent requests to prove its identity, without re-sending credentials.
JSON Web Tokens (JWT)
JSON Web Tokens (JWTs) are a common type of token. They are compact, URL-safe means of representing claims to be transferred between two parties.
A JWT is essentially a string with three parts, separated by dots:
- Header: Describes the token type and signing algorithm.
- Payload: Contains the 'claims' (user data, roles, expiration).
- Signature: Verifies the token's integrity and authenticity.
JWT Header and Payload
Both the Header and Payload are JSON objects, Base64Url-encoded. This encoding makes them safe for URL transmission, but it's not encryption – anyone can read them.
Let's see how to encode a simple Header and Payload in Elixir:
alias Jason
alias Base
defmodule JWTExample do
def encode_part(data) do
data
|> Jason.encode!()
|> Base.url_encode64(padding: false)
end
def main do
header = %{"alg" => "HS256", "typ" => "JWT"}
payload = %{"user_id" => 123, "role" => "admin"}
encoded_header = encode_part(header)
encoded_payload = encode_part(payload)
IO.puts "Encoded Header: " <> encoded_header
IO.puts "Encoded Payload: " <> encoded_payload
end
end
JWTExample.main()JWT Signature Explained
The Signature is crucial for security. It's created by taking the encoded Header, the encoded Payload, a secret key, and the algorithm specified in the header, then cryptographically signing them.
This signature ensures the token hasn't been tampered with. If someone changes the header or payload, the signature verification will fail.
Creating & Verifying a JWT
Here's a full Elixir example demonstrating how to combine the parts to create a simple JWT and then verify its integrity. We'll use a secret key for signing.
Notice how `Base.url_decode64` and `:crypto.mac` are used to simulate JWT logic.
alias Jason
alias Base
defmodule JWTService do
@secret_key "my_super_secret_key_123"
def create_token(payload) do
header = %{"alg" => "HS256", "typ" => "JWT"}
encoded_header = encode_part(header)
encoded_payload = encode_part(payload)
signature = sign(encoded_header, encoded_payload)
"#{encoded_header}.#{encoded_payload}.#{signature}"
end
def verify_token(token) do
[encoded_header, encoded_payload, signature] = String.split(token, ".")
expected_signature = sign(encoded_header, encoded_payload)
if signature == expected_signature do
decoded_payload = encoded_payload |> Base.url_decode64!() |> Jason.decode!()
{:ok, decoded_payload}
else
{:error, "Invalid signature"}
end
end
defp encode_part(data) do
data
|> Jason.encode!()
|> Base.url_encode64(padding: false)
end
defp sign(encoded_header, encoded_payload) do
data_to_sign = "#{encoded_header}.#{encoded_payload}"
:crypto.mac(:hmac, :sha256, @secret_key, data_to_sign)
|> Base.url_encode64(padding: false)
end
def main do
payload = %{"user_id" => 456, "role" => "editor", "exp" => 1678886400}
token = create_token(payload)
IO.puts "Generated Token: " <> token
case verify_token(token) do
{:ok, data} -> IO.puts "Verified! Payload: " <> inspect(data)
{:error, reason} -> IO.puts "Verification Failed: " <> reason
end
# Simulate tampering
tampered_payload = %{"user_id" => 456, "role" => "admin", "exp" => 1678886400}
tampered_token = create_token(tampered_payload)
[h, _p, s] = String.split(tampered_token, ".")
# Replace the payload but keep original signature
tampered_token_str = "#{h}." <> (payload |> Jason.encode!() |> Base.url_encode64(padding: false)) <> ".#{s}"
IO.puts "\nTampered Token: " <> tampered_token_str
case verify_token(tampered_token_str) do
{:ok, data} -> IO.puts "Verified (unexpectedly)! Payload: " <> inspect(data)
{:error, reason} -> IO.puts "Tampering Detected: " <> reason
end
end
end
JWTService.main()What is Authorization?
Once a user is authenticated (we know who they are), Authorization determines what actions they are allowed to perform and what resources they can access.
It's about permissions. For example, an 'admin' user might be able to delete posts, while a 'guest' user can only view them.
Role-Based Access Control (RBAC)
A common authorization strategy is Role-Based Access Control (RBAC).
- Users are assigned one or more roles (e.g., 'admin', 'editor', 'viewer').
- Each role has a predefined set of permissions (e.g., 'create_post', 'edit_own_post', 'delete_any_post').
- When a request comes in, the system checks if the authenticated user's role has the necessary permission for the requested action.
Authorization with Phoenix Plugs
In Phoenix, Plugs are an excellent way to implement authorization logic. A Plug is a modular function that processes requests.
You can create a Plug that checks the user's role (often extracted from a JWT payload) before allowing access to a controller action or an entire scope of routes.
For example, a `RequireAdminPlug` would halt the request if the user's role isn't 'admin'.
JWT & Authz Check
Which of the following statements about JWTs and API security are TRUE?
Summary: Secure Your APIs
You've learned the fundamentals of securing API endpoints!
- Authentication confirms identity, often using tokens like JWTs.
- JWTs consist of an encoded Header, Payload, and a cryptographic Signature for integrity.
- Authorization defines what an authenticated user can do, commonly managed with Role-Based Access Control (RBAC).
- Phoenix Plugs are ideal for implementing authorization checks in your API routes.
Keep exploring security best practices to build robust and safe applications!
Perguntas Frequentes
A aula “Estratégias de Autenticação e Autorização” é grátis?
Sim — o texto completo de “Estratégias de Autenticação e Autorização” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Elixir & Phoenix: Scalable Backend Development, atualize para CoddyKit PRO. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.
O que vou aprender em “Estratégias de Autenticação e Autorização”?
Proteja seus endpoints de API usando métodos comuns de autenticação, como JWT, e implemente regras de autorização. Você pratica Elixir & Phoenix: Scalable Backend Development com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Elixir & Phoenix: Scalable Backend Development?
Nenhuma experiência prévia é necessária. Elixir & Phoenix: Scalable Backend Development no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Estratégias de Autenticação e Autorização”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Elixir & Phoenix: Scalable Backend Development?
Sim. Cada aula de Elixir & Phoenix: Scalable Backend Development inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Princípios e Boas Práticas de Design de APIs
- Implementação de Endpoints de API e Serialização
- Estratégias de Autenticação e Autorização
- Paginação, Filtragem e Versionamento de APIs