Entenda de uma vez o significado dos códigos de status HTTP, como eles funcionam, quais os mais comuns e como lidar com cada um deles.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na aula de hoje eu vou te mostrar os códigos de status HTTP, explicando seus funcionamentos, quais são os mais comuns de encontrarmos e como lidar com eles para identificar se algo está sendo feito incorretamente ou se o problema está em outro lugar.
Os códigos de status HTTP são utilizados para informar ao usuário sobre problemas ou fornecer informações relacionadas aos erros encontrados. Um exemplo conhecido é o erro 404, que indica que a página não foi encontrada ou não existe.
Além desse código, existem diversos outros status agrupados nas famílias 1XX, 2XX, 3XX, 4XX e 5XX. Durante esta aula, vou apresentar cada uma dessas famílias de códigos de status HTTP.
Para acompanhar o conteúdo, faça o download do material disponível, pois utilizaremos exemplos práticos para ilustrar cada um desses códigos de status.
Além disso, utilizarei o VS Code para esta aula, mas você pode utilizar o editor de códigos da sua preferência.
Ao longo desta aula, faremos uso das bibliotecas Flask e Requests. Portanto, o primeiro passo será instalar essas duas bibliotecas em seu computador. Para isso, execute o seguinte comando no terminal do seu editor de códigos:
pip install flask requestsQuando acessamos um site, estamos enviando uma solicitação para o servidor daquele site e, como resposta, o servidor retorna a página que desejamos visualizar. Por exemplo, ao acessar a página inicial do Google.
Se a resposta for bem-sucedida, significa que o servidor conseguiu fornecer a página solicitada como resposta à nossa requisição. Toda resposta que recebemos de um servidor está acompanhada por um código de status HTTP.
O código de status enviado pelo servidor quando tudo ocorre conforme esperado e a página do site é carregada normalmente é o código 200, que indica que está tudo ok.
O mesmo ocorre quando tentamos acessar uma página que não existe ou não pode ser encontrada. Nesse caso, o código de status HTTP que recebemos é o conhecido 404.
Esses são apenas dois dos principais códigos de status HTTP. Por meio de nosso exemplo de código, conheceremos outros códigos importantes das famílias 1XX, 2XX, 3XX, 4XX e 5XX.
O código presente no material para download é de um site muito simples desenvolvido com Flask. Esse site possui apenas uma página inicial, que exibe a mensagem “Meu site no Ar”.
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar"
if __name__ == "__main__":
app.run(debug=True)Após instalar o Flask e executar esse código, ele colocará o site no ar em um link que representa o seu servidor local, acessível apenas dentro do seu computador.
Ao acessar esse link, você será redirecionado para o site.
Ao voltarmos para o editor de códigos e observarmos o terminal, poderemos ver os códigos de status HTTP sendo exibidos para o nosso site.
Ao fazer uma requisição do tipo GET, estamos solicitando informações do site e recebendo uma resposta. Nesse caso, como tudo está funcionando corretamente, o código de status 200 será exibido, indicando que está tudo ok.
A primeira família de códigos de status HTTP é a família 1XX. Embora você não encontre muitos desses códigos, é importante conhecer sua existência. Eles são códigos informacionais, retornam apenas respostas informativas sobre a requisição feita.
A família dos códigos 2XX são códigos de status HTTP que indicam respostas bem-sucedidas. Eles sinalizam que a requisição foi processada com sucesso.
Existem vários códigos pertencentes à família 2XX que podem ser recebidos. Para simular alguns desses códigos, utilizaremos a biblioteca requests em conjunto com nosso site.
Em outro arquivo, vamos importar a biblioteca requests, criar uma requisição para nosso site e imprimir essa requisição, bem como a requisicao.reason, que exibe a explicação do código de resposta.
import requests
requisicao = requests.get("http://127.0.0.1:5000/")
print(requisicao)
print(requisicao.reason)Ao executar esse código com nosso site aberto, obteremos o código de status 200, e requisicao.reason retornará o texto “OK“, indicando que recebemos uma resposta bem-sucedida.
O próximo código da família 2XX é o código de status HTTP 201. Além de indicar que a requisição foi bem-sucedida, ele representa o status de CREATED.
Para visualizarmos isso, faremos uma modificação no código de nosso site, adicionando o código 201 ao retorno da nossa página.
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar", 201
if __name__ == "__main__":
app.run(debug=True)Ao fazer uma requisição para nosso site, agora receberemos como resposta o código 201 e a mensagem CREATED. Essa resposta indica que, além da requisição ter sido bem-sucedida, um novo registro foi criado no sistema.
Por exemplo, quando um aluno visita o site da Hashtag e realiza a matrícula em um dos nossos cursos, ele receberá uma resposta de sucesso, bem como o código 201 de CREATED, pois o registro daquela matrícula foi criado no sistema.
Muitos sites acabam retornando apenas o status 200 para o usuário final, mesmo em casos em que ocorre a criação de um novo registro no sistema. Isso ocorre porque, como vimos, podemos definir o código que desejamos retornar no return de nosso site.
Agora, veremos o código 202, o próximo da família 2XX. Esse código representa a mensagem ACCEPTED, que significa que a requisição foi aceita e está sendo processada, mas o servidor ainda não terminou de processar todas as informações contidas nela.
Voltando ao exemplo do aluno, quando ele compra um dos cursos, é necessário realizar diversas configurações para esse usuário na plataforma. Portanto, retornamos o código 202 de ACCEPTED. Isso significa que a compra foi bem-sucedida, a requisição foi aceita, mas ainda existem informações sendo processadas.
O último código de status HTTP que veremos nessa família é o 204, que representa o NO CONTENT Esse status indica que a requisição foi bem-sucedida, mas não há conteúdo para ser retornado pelo servidor como resposta.
Os códigos de Status HTTP da família 3XX, são códigos de redirecionamento. Esses códigos são retornados quando a resposta da requisição não está no local exato onde foi solicitada. Isso pode ocorrer quando o endereço foi alterado permanentemente ou quando há mais de uma resposta possível para a requisição.
O primeiro código dessa família que veremos é o 301. Ele indica que a URL solicitada foi permanentemente modificada, e a nova URL é retornada como resposta para o usuário, redirecionando-o para ela.
Para visualizarmos isso com nossos exemplos, criaremos um novo endpoint para nosso site.
É importante lembrar que o objetivo dessa aula é compreender melhor os códigos de status HTTP. Caso queira aprender mais sobre a criação de sites com Flask, recomendo nosso minicurso gratuito de criação de sites com Python, onde você aprenderá a criar uma réplica do Pinterest.
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar"
@app.route("/link_antigo")
def sumiu():
return redirect(url_for("homepage"), code=301)
if __name__ == "__main__":
app.run(debug=True)Com isso, criamos o que seria um link antigo que redireciona para a homepage atual do site. Se fizermos uma requisição para esse endereço usando o link antigo:
import requests
requisicao = requests.get("http://127.0.0.1:5000/link_antigo")
print(requisicao)
print(requisicao.reason)Receberemos como resposta o código da página inicial, ou seja, o código 200, indicando que está tudo certo, pois o usuário foi redirecionado para a homepage. No entanto, se observarmos o registro do servidor do nosso site, veremos que antes disso, foi retornado o código 301.
Esse código é utilizado quando você redireciona a partir de um link que não existe mais e não existirá mais em seu site. Um link que foi modificado permanentemente.
Outro código similar dessa família é o 302. No entanto, ao contrário do 301, esse código de status é retornado quando o endereço solicitado foi modificado temporariamente. Ou seja, por enquanto, esse link levará para um redirecionamento, mas futuramente pode ser que ele receba outra atribuição.
Os códigos da família 4XX são códigos de status HTTP que retornam respostas de erro ao usuário. Esses códigos são gerados quando a causa do erro provém do lado do cliente, e não do servidor.
O primeiro código que veremos é o 400, que indica o erro de Bad Request. Esse código significa que o usuário está enviando uma requisição em um formato incorreto.
Para visualizarmos isso, criaremos mais um endpoint para nosso site:
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar"
@app.route("/link_antigo")
def sumiu():
return redirect(url_for("homepage"), code=301)
@app.route("/usuario/<id>")
def usuario(id):
try:
id = int(id)
return f"Usuário {id} carregado com sucesso"
except:
return "Erro na requisição", 400
if __name__ == "__main__":
app.run(debug=True)Dessa forma, criamos um link que direciona para a página do usuário. Para identificar qual usuário será acessado, passamos um ID no endereço, que deve ser um número inteiro.
Agora, se o cliente fizer uma requisição com algo que não seja um número inteiro na URL, ele receberá o erro 400.
No registro do servidor, podemos ver o status 400.
Outro código de status HTTP importante da família 4XX é o 401. Esse status é chamado de Unauthorized.
Ele é retornado quando o usuário tenta acessar ou fazer uma requisição a um endereço no qual ele não está autenticado. Isso significa que o usuário ainda não se cadastrou ou fez login no servidor, e sua identidade não é conhecida pelo servidor.
Ao contrário do 401, temos o código de status 403, o Forbidden. Nesse caso, o usuário já é reconhecido pelo servidor, mas não tem permissão de acesso ao recurso solicitado em sua requisição. Por exemplo, tentar acessar o painel de administração de um site.
Nessa família também temos o famoso erro 404 de página não encontrada.
Por fim, veremos o erro 405, o Method Not Allowed. Esse erro ocorre quando o método da requisição é conhecido pelo servidor, mas não é permitido.
Por exemplo, imagine que seu site ou API possui um webhook (um link que permite o envio de informações para o seu site). Vamos criar um exemplo de webhook que aceita apenas requisições do tipo POST (envio de informações para o site)
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar"
@app.route("/link_antigo")
def sumiu():
return redirect(url_for("homepage"), code=301)
@app.route("/usuario/<id>")
def usuario(id):
try:
id = int(id)
return f"Usuário {id} carregado com sucesso"
except:
return "Erro na requisição", 400
@app.route("/webhook", methods=["POST"])
def webhook():
return "OK"
if __name__ == "__main__":
app.run(debug=True)Se tentarmos acessar esse link de webhook pelo navegador ou fizermos uma requisição do tipo GET para ele usando nosso código, receberemos o erro 405.
import requests
requisicao = requests.get("http://127.0.0.1:5000/webhook")
print(requisicao)
print(requisicao.reason)
Assim como a família dos códigos 4XX retornam erros por parte do usuário. A família de códigos 5XX são códigos de status HTTP que retornam respostas de erros provenientes do lado do servidor.
O código mais comum é o 500, Internal Server Error (erro interno do servidor), que indica um problema não especificado no lado do servidor.
Para ilustrar esse erro, vamos adicionar uma funcionalidade em nosso site que permite visualizar a foto do usuário. Quando o usuário acessar o endpoint /foto_usuario/<id>, a função foto_usuario(id) será acionada. Porém, nesse caso, não faremos validações para lidar com um ID inválido.
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar"
@app.route("/link_antigo")
def sumiu():
return redirect(url_for("homepage"), code=301)
@app.route("/usuario/<id>")
def usuario(id):
try:
id = int(id)
return f"Usuário {id} carregado com sucesso"
except:
return "Erro na requisição", 400
@app.route("/webhook", methods=["POST"])
def webhook():
return "OK"
@app.route("/foto_usuario/<id>")
def foto_usuario(id):
id = int(id)
return f"Foto do usuario {id} carregado com sucesso"
if __name__ == "__main__":
app.run()Ao acessar um ID inválido, em vez de receber uma mensagem de erro 400, o usuário verá uma mensagem de erro interno do servidor. Isso indica que há um problema no servidor que precisa ser corrigido.
Outro código de status importante é o 501, Not Implemented. Esse código é retornado quando uma parte do site ainda está em construção e não foi implementada. A funcionalidade existe, mas ainda não está ativa, não foi feito o deploy dela.
No nosso exemplo, podemos adicionar um endpoint /postar_foto que retorna uma mensagem “Em construção” com o código 501.
from flask import Flask, redirect, url_for
app = Flask(__name__)
@app.route("/")
def homepage():
return "Meu site no Ar"
@app.route("/link_antigo")
def sumiu():
return redirect(url_for("homepage"), code=301)
@app.route("/usuario/<id>")
def usuario(id):
try:
id = int(id)
return f"Usuário {id} carregado com sucesso"
except:
return "Erro na requisição", 400
@app.route("/webhook", methods=["POST"])
def webhook():
return "OK"
@app.route("/foto_usuario/<id>")
def foto_usuario(id):
id = int(id)
return f"Foto do usuario {id} carregado com sucesso"
@app.route("/postar_foto")
def postar_foto():
return "Em construção", 501
if __name__ == "__main__":
app.run(debug=True)
Outro código de status é o 502, Bad Gateway. Esse erro ocorre quando o servidor recebe uma resposta inválida ao tentar lidar com uma solicitação.
Isso geralmente acontece quando o site precisa se comunicar com um serviço externo ou outro servidor, e ocorre um problema na comunicação entre eles.
Por fim, o código de status 503, Service Unavailable , indica que o servidor não está preparado para lidar com a solicitação. Isso pode ocorrer quando o servidor está em manutenção ou sobrecarregado.
Esses códigos de status da família 5XX são úteis para identificar e solucionar problemas no servidor, permitindo que os administradores do site possam corrigir as falhas e garantir uma experiência melhor aos usuários.
Nesta aula, aprendemos sobre os códigos de status HTTP, o que são e como funcionam. Exploramos os principais e mais comuns códigos que encontramos ao trabalhar com o desenvolvimento de sites.
Além disso, exemplifiquei como e quando cada um desses códigos acontece através de um código simples de um site criado com Flask. Caso queira se aprofundar mais no desenvolvimento de sites com Flask no Python, não se esqueça do nosso minicurso gratuito.
É importante ressaltar que existem outros códigos de status HTTP que não foram abordados nesta aula, no entanto, os códigos mencionados são os principais e mais frequentes. Portanto, ao se deparar com qualquer um desses códigos, você já terá conhecimento do que se trata e se está cometendo algum erro ou não.
Para acessar outras publicações de Python, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.
Quer sair do zero no Python e virar uma referência na sua empresa? Inscreva-se agora mesmo no Python Impressionador