API com Django 3: Testes, segurança e lapidações

Upload de arquivos estáticos - Apresentação

Olá! Meu nome é Guilherme Lima e eu serei o seu instrutor nesse treinamento de API com Django 3 Testes, Segurança e Lapidações. O que nós vamos aprender nesse curso? Nesse curso vamos aprender a incluir uploads de arquivos nas requisições e na API, vamos aprender a trabalhar com Caching e vincular o Django com Redis.

Vamos aprender a realizar a internacionalização das nossas requisições para diferentes idiomas. Vamos realizar os testes das principais requisições que temos e vamos dar uma pitada de segurança nas aplicações desenvolvidas com Django para deixarmos o nosso projeto bem legal e completo.

Quais são os pré-requisitos para esse curso? É muito importante que você tenha feito os cursos anteriores de Django para nós mantermos uma continuidade também nos nossos estudos. Principalmente nos cursos de desenvolvimento de API.

Qual é o público alvo desse curso? Se você quer aprender a trabalhar com Caching, Segurança, desenvolvimento de API e aprofundar os seus conhecimentos, você é muito mais do que convidado para realizar esse treinamento comigo! Sabendo de tudo isso, vamos começar?

Upload de arquivos estáticos - Incluindo campo foto

Olá, pessoal! Sejam muito bem-vindos a mais um treinamento da Alura! Vamos iniciar os nossos estudos? Na atividade anterior a esse vídeo tivemos um passo a passo de como você carrega esse projeto. Esse projeto é uma continuação do projeto anterior. Então se você fez, poderá dar sequência.

Se você quer aprender os assuntos desse projeto, desse escopo do nosso treinamento, você pode carregar esse projeto. Temos o passo a passo de como você faz isso. Então, vamos lá! Esse curso se trata de uma API onde nós vamos disponibilizar recursos de alunos, cursos e matrículas. Então temos uma série de alunos que já deixamos certa, para você conseguir carregar também essa base de dados.

Temos alguns cursos e nas matrículas não temos nenhuma matricula ainda, porque não vamos trabalhar com elas por enquanto. Vou voltar. Qual é nosso foco inicial? Se acessamos http://localhost:8000/alunos/, nós podemos observar que temos o “id”, o “nome”, o “rg”, o “cpf” e a “data_nascimento”.

E se observarmos no curso anterior, o que havíamos feito? No “escola > serializer.py” nós temos um outro Aluno. Uma versão 2 desse Aluno, onde disponibilizamos mais um recurso, que é o recurso de celular. Então se eu coloco, por exemplo, “?version=v2”, nós podemos ver que o campo “Celular” aparece para alguns alunos.

Se eu volto na versão normal, ele não aparece. Só que agora ele tem uma seguinte situação: para ambas as versões nós vamos precisar incluir uma foto para os alunos, um arquivo estático. Como fazemos isso no Django? Como configuramos o Django para que ele continue a receber uploads de arquivos?

Então, além desses campos, eu quero criar mais um campo chamado “foto”. Vamos fazer isso? Vamos fechar o “serializer.py”. A primeira coisa que vamos fazer é: existe um módulo que vai nos auxiliar com essa transição das fotos, porque quando fizermos um post de um aluno com uma foto, é necessário que a foto vá para um lugar e armazenemos o caminho daquela foto. Como fazemos isso?

Existe um módulo que vamos instalar com o pip install, chamado pillow. Ele vai ser responsável por fazer esse meio de campo para nós. Podemos até acessar ele aqui. Vou digitar pillow django para conseguirmos ver. Aqui, o pillow. Esse é um módulo que vamos instalar. Então ele vai nos auxiliar com essa manipulação de imagens dentro da API.

Instalamos o pillow para mantermos o bom funcionamento da nossa API e dos arquivos e do que estamos fazendo. No “requirements.txt” é importante passarmos esse módulo que criamos. Vou fazer como? Vou colocar um pip freeze > requirements. Deixe-me só confirmar se escrevi certo... Está requirements.txt, parece que sim.

E aparece o Pillow para nós. Vou fechar. Qual é nosso próximo passo? Se acessarmos o “setup - settings.py” vamos ver que já existe um “STATIC_URL”. Podemos até ver que ele fala “Follow link (cmd + click) JavaScript, Images”. Já temos essa configuração, mas é necessário que incluamos mais duas configurações para que nossos arquivos estáticos e que nossa foto, funcionem na API.

O que vou fazer? Vou jogar esse STATIC_URL = '/static/' lá para baixo. Vou deixar ele aqui mesmo. Ia jogar ele ali para baixo, mas como está certo, deixe-me só tirar esses outros para não ficarmos confusos.

O que vou fazer? Temos um caminho para os arquivos estáticos. Agora vamos precisar criar um root para essas medias. Vou chamar de “MEDIA_ROOT”. Qual vai ser a responsabilidade desse arquivo? Ele vai falar “a mídia dos arquivos estáticos está nesse caminho”, então vamos passar um caminho, os.path.join. Vou dizer que ele está no diretório principal, no BASE_DIR e vou dizer que o nome dele vai ser media_root.

Uma outra variável que vamos precisar setar no “settings.py” é o MEDIA_URL. Por quê? Quando acessarmos a nossa API não vamos exibir a foto de todos os alunos, vamos exibir a URL indicando a foto para cada aluno. Então vou colocar MEDIA_URL = '/media/'. Todas as MEDIA_URL terão a referência do MEDIA_ROOT. Vou tirar esses espaços para não ficarmos com um monte de linhas sobrando.

Configuramos o “settings.py”, por aqui não precisamos mexer mais. Vou no modelo de escola onde temos todas as bases do aluno e vou incluir um novo campo, que vou chamar de foto = e ele vai ser do tipo models.ImageField(). Olhe que legal, já temos uma propriedade para indicarmos essas fotos.

E aqui tem um ponto importante: as fotos podem ser preenchidas e indicadas no novo recurso. O que acontece? Quando formos dar um post, poderá ter uma foto ou não. Então vou indicar a propriedade blank=true. Então vamos permitir que alguns alunos tenham fotos e outros não.

Só que o true aqui precisa ser com letra maiúscula, então True. Apertei as teclas “Command + J”. Nós vamos fazer essa migração para a base de dados. Deixe-me virar nossa tela. O que vou fazer? A primeira coisa: python manage.py makemigrations para ele migrar esse cenário de inclusão de fotos em alunos.

Ele falou que está adicionando o campo foto no aluno. O que vou fazer agora? Vou migrar, vou passar essas migrações para o banco de dados, python manage.py migrate. Beleza, a foto foi criada!

Vou subir meu servidor mais uma vez, digitando manage.py runserver”, apertando a tecla “Enter” e voltando na nossa aplicação. Vou fechar a documentação do pillow. Está atualizando.

Observe que não estamos conseguindo enxergar nada. Por quê? Porque colocamos essas alterações no nosso modelo, mas não passamos pelo Serializer. Lembra que temos dois serializers e ambos, é um escopo, um cenário fictício da nossa aplicação, eles precisam do campo “foto”.

Então vou colocar , 'foto' no AlunoSerializer. No AlunoSerializerV2 também vou colocar vírgula , 'foto'. Salvei. Voltando para o Django e atualizando.

Observe que agora apareceu lá ““foto”: null”. Se eu scrolar lá para o final, olhe o que vai acontecer! No final temos o campo “Foto” para escolhermos.

Não faça o upload da foto ainda. Vamos fazer isso na sequência, no próximo vídeo.

Upload de arquivos estáticos - Upload de arquivos

Vamos realizar o teste incluindo uma nova foto? Criei alguns dados só para realizarmos esse teste nos campos “Nome”, “RG” e “CPF” e “Data nascimento”. Tenho duas fotos que vou usar. Tenho essa foto aqui e depois vamos testar o update dessas fotos. Vamos lá!

Vou criar, vou selecionar no campo “Foto > Choose File > foto-1.png > Open”. Ele carregou a “foto-1.png”. Se observarmos nos nossos arquivos, nós temos “escola”, “setup”, “venv”, o “git” e outras informações.

Quando eu clicar em “POST”, observem o que vai acontecer. Ele incluiu a URL de “foto-1.png” e no projeto ele criou o “media_root” onde tem a “foto-1.png”. Vou clicar na “foto-1.png” e nós temos um “Page not found”. Que estranho! Por que isso está acontecendo? Olhe que interessante.

Configuramos no “setting.py” do arquivo de “setup > setup - setting.py”. O que fizemos? Fizemos uma configuração e falamos assim: “temos a raiz, o MEDIA_ROOT onde vamos manter nossas imagens e temos o MEDIA_URL“. Só que em nenhum momento falamos para a nossa aplicação, para o path das nossas aplicações que temos arquivos estáticos para serem carregados - e precisamos fazer isso.

Onde fazemos isso? Se eu preciso indicar as minhas URLs que tenho em arquivos estáticos, eu vou em “urls.py”. Vou fechar o “settings.py”. Vou deixar essa tela maior para conseguirmos ver. Acessando a “urls.py” nós vamos importar aquelas duas propriedades: o settings e o static. Lá do “django.conf” quero importar os settings e também quero importar from django.conf.urls.static import static.

Então olhe só, temos as rotas de cada recurso e as URLs da aplicação. O que vou precisar indicar? Vou precisar falar assim: “além de todos esses paths, eu tenho a inclusão de arquivos estáticos e nós fazemos isso com sinal de maior”. Vou colocar static e vou passar essas duas variáveis.

Vou passar lá do “(settings.MEDIA_URL(” e vou passar também o local onde estão os nossos documentos, as nossas imagens e arquivos estáticos, para isso vou colocar “document_root=settings.MEDIA_ROOT”. Fechei os parênteses? Não fechei. Deixe-me fechar os parênteses. Salvei. Abrindo o servidor parece que está tudo OK.

Quando volto na aplicação e atualizo, olhe que interessante, a imagem carrega. O que precisamos fazer, então? Duas etapas: configuramos o settings para que ele tenha o caminho certo do MEDIA_URL e da MEDIA_ROOT, onde de fato nossos arquivos estáticos vão ficar. Depois aqui no “urls.py” nós indicamos que temos arquivos estáticos para serem carregados.

Então, o que podemos fazer agora? Olhe só no navegador, criamos o aluno “201”. Vou acessar a página localhost:8000/alunos/201. Acessando esse aluno temos todas essas informações. Todas as vezes que acessamos às informações, conseguimos ver que tem a “foto-1.png”.

Só que por padrão do HTML, do funcionamento, a imagem não aparece aqui. Ela fica vinculada ali em cima. Vou alterar. Então vou utilizar a “foto 2” para esse teste, em “Choose File > foto-2.png > PUT”. Ele alterou.

Então nós temos o valor “201”, só que agora utilizando a “foto-2”. Dessa forma, conseguimos incluir os recursos de alunos arquivos estáticos!

Sobre o curso API com Django 3: Testes, segurança e lapidações

O curso API com Django 3: Testes, segurança e lapidações possui 96 minutos de vídeos, em um total de 37 atividades. Gostou? Conheça nossos outros cursos de Python em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Upload de arquivos estáticos
• Caching
• I18N e content negotiation
• Testes
• Segurança