Curso de FastAPI - Rest API com Python (Backend Completo) - Aula 01: Apresentação do Projeto

Impressionadores, projeto novo aqui no canal, ensinando para vocês de forma completa como que funciona um projeto de ponta a ponta no FPI para criar um backend completo de uma API. Vocês vão ver que os vídeos que fazem parte dessa sequência de aulas, elas vão ter um formato um pouco diferente. Por quê?

Porque a gente tá pela primeira vez disponibilizando aqui para vocês no canal do YouTube meio que um compilado de um projeto que a gente tá construindo para disponibilizar na plataforma pros nossos alunos. Então isso daqui vai ser um projeto que a gente vai disponibilizar paraos nossos alunos, mas pela primeira vez eu tô trazendo isso de forma gratuita para vocês aqui dentro do YouTube. Quem quiser entrar em mais detalhes, quiser tirar tirar dúvidas e tudo mais, aí realmente só os nossos alunos vão ter acesso a isso.

O link para você saber mais sobre cursos e tudo mais vai estar sempre aqui na descrição de todos os vídeos, como sempre tem. Mas o meu objetivo aqui é conseguir disponibilizar para vocês aqui dentro do YouTube numa playlist única, um projeto completo de FPI ponta a ponto. Então vocês vai ver, vocês vão ver que ao longo das aulas que a gente vai ter aqui, eh cada aula ela vai ser, na verdade, uma junção de duas, três, quatro aulas, que são aulas normalmente menores, mais separadas e mais organizadas que a gente disponibiliza na plataforma pros nossos alunos.

Mas aqui para vocês, isso vai est compilado em menos vídeos, pra gente não demorar muito para liberar o conteúdo todo para vocês, beleza? Isso vai ser liberado em formatos de duas aulas por semana, então uma aula terça e uma aula quinta, que é normalmente quando a gente libera os nossos cursos de Python. E a expectativa aí é que isso demore em torno, digamos assim, de umas quatro c semanas pra gente liberar todo o conteúdo de Fest API para vocês.

Depois vai ficar numa playlist organizadinha. Dependendo do momento que você estiver vendo esse vídeo, essa playlist já existe. O link da playlist vai estar aqui na descrição do vídeo.

É só você acompanhar as aulas que você vai fazer esse projeto de Festpi PI de ponta a ponta. E vamos começar com a apresentação do projeto. Espero de verdade que vocês gostem muito dessa linha editorial nova assim que a gente criou aqui, disponibilizou para vocês.

Se você gostou, deixa aqui nos comentários, deixa aqui a sua opinião, deixa aqui o que que você quer saber, o que mais você quer aprender, tipos de projetos que você quer ver aqui com a gente, que a gente tá sempre de olho. Um grande abraço e vamos lá começar. [Música] Fala, galera.

Sejam bem-vindos ao nosso curso de Fast API. Durante esse curso, efetivamente, na verdade, a gente vai criar um projeto único, onde a gente vai do início ao fim, partir de um arquivo completamente zerado, a gente vai abrir nosso VS Code, criar um projeto ali do zero e vai criar todos os arquivos que a gente precisa, todas essas instalações pra gente criar o que seria um sistema de delivery de pizzaria usando toda a estrutura do Fest API num formato de uma REST API, tudo com autenticação, como vocês podem ver aqui, com e end point de ordens, com esquemas, com banco de dados, com planejamento. requirements, eh, modelos, dependências, todas as práticas mais recomendadas do uso de fest API, funções assíncronas e muito mais.

A gente vai passo a passo evoluindo aqui ao longo desse curso, partindo do zero, vocês vão aprendendo ao longo desse projeto efetivamente todas as estruturas que o Fest CPI precisa. Eu tentei consolidar aqui o conhecimento de várias formas diferentes, tanto da documentação atual do FPI no momento que eu tô gravando esse vídeo, quanto de exemplos que você vai encontrar em outros lugares da internet. Tem muita coisa aqui que foi atualizado recentemente e com boas práticas recomendadas tanto pela documentação quanto por pessoas que utilizam FPI.

E no final do nosso projeto a gente vai colocar esse projeto todo lá no GitHub pra gente ter ele disponível pra gente. Beleza? Espero em verdade que vocês gostem de todo o projeto.

Vamos começar, vamos partir do zero, vamos criar aqui, mas só para mostrar para vocês, a gente vai conseguir fazer todo o processo de criação de um usuário, de login. A gente vai, vou mostrar para vocês como que a gente faz requisições de tipo get, requisições de tipo post, requisições dos outros tipos, como delete, ou patch também. A gente vai poder adaptar isso se a gente quiser aqui.

E efetivamente ter, digamos assim, um projeto de um backend completo, integrando com banco de dados, com tudo mais dentro desse projeto tudo. Beleza? Vamos lá, vamos começar.

Bom, galera, esse daqui é, digamos assim, o gabarito do nosso projeto rodando. Lembrando que como a gente tá usando FPI, o FPI ele é a estrutura do Python que permite a gente construir a parte de backend dos sites. Então, essencialmente, o que ele vai permitir a gente fazer é criar uma API, que nada mais é do que essa interface, que aqui no caso do FCPI, ele cria essa documentação pra gente, que vai dar essa interface visual pra gente poder visualizar, mas essencialmente ele vai criar aqui os end points do nosso site, né?

Ou seja, quando eu entrar lá no site que vai ter o link do site barra off/signup, eu vou criar o novo usuário. Quando eu entrar no barra off/signin, eu vou fazer o login no usuário. Quando eu entrar no barra orders, ele vai executar o que tá aqui dentro.

Só para mostrar um exemplo para vocês. Se eu entrar no site, no barra orders, ele vai executar o que tá aqui. O que que é que ele vai executar aqui?

Ele fala, ó, isso é uma rota de teste inicial para mostrar o que acontece no end point de ordens. E aí, e repara, essa requisição aqui, ela não faz nada. O legal do FPI é que ele cria pra gente essa interfaceinha onde a gente pode testar todos os links do nosso site do Endpo então essencialmente você poderia ter um front endu site ou enfim um um outro serviço que vai fazer chamadas, fazer requisições para esses links aqui.

Esses links vão responder informações. Você pode, o FPI, ele cria essa documentação já para você aqui toda pronta. Quando você cria o seu código, você não precisa definir nada aqui, ele já vai criar essa estrutura toda para você.

Então você pode simular essas requisições. Por exemplo, se eu fizer aqui, ó, clicar aqui em try out, ele vai me mostrar que eu consigo fazer requisições para esse end point aqui. Qual vai ser a resposta?

Só clicando aqui em executar, ele vai executar e ele vai mostrar, olha, fiz uma requisição para cá, a resposta de erro vai ser não autorizado, porque eu defini que todos os usuários que tentam acessar, que toda a requisição que chega na ordem tem que vir autenticada, tem que se passar por um usuário que passou pela autenticação. Se eu fizesse aqui, por exemplo, no off especificamente, aqui eu não defini isso. Então, se eu clicar aqui em try it outar, na verdade aqui eu defini isso também.

Então ele fala não autenticado. No outros end points eu não defini isso. Então por exemplo, para eu fazer o login, eu não preciso fazer isso.

Mas aqui para fazer o login, eu preciso passar o e-mail e a senha para eu fazer o login, para eu poder entrar dentro do meu do meu sistema e assim vai. Beleza? Então o que a gente vai definir dentro do nosso projeto são justamente todas essas rotas que a gente vai querer ter no nosso projeto e vai criar a funcionalidade de todas elas que vai fazer integração com o banco de dados e tudo mais e assim vai.

Eu vou mostrar como que o projeto tá dividido, só paraa gente conseguir entender um pouco na prática como que isso vai acontecer, mas a gente vai construir isso a partir de agora do zero mesmo, tá? Então, essencialmente pro FCPI funcionar bem, você pode, você pode ter divisões diferentes disso, mas a uma divisão recomendada essencialmente seria você vai ter um arquivo inicial que vai ser o seu arquivo de main, que é esse arquivo que vocês estão vendo aqui agora, onde ele você vai criar o seu FPI e vai definir algumas configurações que a gente vai falar sobre elas. Então não quero que vocês se preocupem agora nesse início, nessa aula, sobre tudo que tá escrito aqui, porque a gente vai criar isso aqui tudo do zero.

Mas essalmente você define o FS API aqui, cria as configurações de criptografia e chama as rotas do seu site. As rotas do seu site são efetivamente esses linkzinhos que você tá vendo aqui, esses end points, que é o que que o seu site vai, quais são os links do seu site que ele vai conseguir acessar. Se usuário acessasse no link do seu site barra orders, ele essencialmente estaria fazendo uma requisição do tipo gets no orders, que é a mesma coisa que ele tem na resposta aqui.

Tanto que se eu copiar esse link daqui com barra orders e entrar aqui num outro link e acessar, ele vai me dar o mesmo erro noticated que ele vai me dar se eu entrar aqui no linkzinho de order e clicar aqui no try it out executar. E aí vai falar notent, tá vendo? vai dar mesma informação que tá aqui, ele vai me dar aqui, porque essencialmente é a mesma coisa que tá acontecendo.

E aí você tem requisições de outro tipo, tipo post, tudo mais, que você vai ter que fazer por meio dos seus códigos ou por meio de um front end e assim vai. Beleza? Então o main é isso.

E aí você vai ter arquivos de rota, que são os arquivos onde você vai definir essas categorias aqui. Como no nosso caso a gente vai criar autenticação, eu vou separar isso em duas categorias. Você poderia ter tudo numa coisa só, mas eu vou separar em duas categorias.

da categoria de é rotas de autenticação, ou seja, quais são os links do meu site, as coisas da minha PI, né? Eu vou sempre chamar aqui de end points da minha PI. Pint da minha P.

Sempre que eu falar isso, entenda os links da sua PI, né? Que vai ser sempre o link do seu site barra o texto que tá escrito aqui, off/signup. Então os end points da sua API, que é como a gente chama esses links que ficam disponíveis aqui de que tem a ver com a autenticação.

E a gente vai ter aqui uma autenticação muito famosa do Fest API, que é autenticação por meio de tokens, tanto autenticação por meio de access tokens quanto por refresh tokens, que a gente chama de JWT. A gente vai falar sobre isso mais à frente, não precisa olhar muito isso agora, só querendo apresentar para vocês. Então a gente vai ter as nossas notas de autenticação e as nossas notas de pedido, né?

Ou seja, quando eu vou criar um pedido numa pizzaria, lembrando que a gente tá fazendo um backend de uma delivery de pizzaria. Eu quando eu for criar um pedido numa pizzaria, eu tenho que criar o pedido. Eu tenho que adicionar produtos dentro daquele pedido ou tirar produtos dentro daquele pedido.

Enfim, tem que escolher o que eu vou fazer com ele. E eu posso finalizar aquele pedido, entregar aquele pedido, reconhecer ele e tudo mais. Então são basicamente as rotas que a gente vai definir aqui, tá?

Isso tudo a gente vai definir nesses arquivos de rotas. Só que para esses arquivos de rotas funcionarem, eles vão precisar de outras estruturas. As estruturas principais que a gente vai precisar é de um banco de dados.

Então, a gente vai ter que criar um banco de dados para ele poder armazenar os pedidos feitos, usuários criados e tudo mais. A gente vai precisar do nosso arquivo de modelos, que é quem vai definir quais são as tabelas do nosso banco de dados. Então, esse arquivo de modelos, ele vai fazer esse processo, ele vai definir, ah, eu vou ter uma tabela de usuários, eu vou ter uma tabela de pedidos, eu vou ter uma tabela de itens de pedidos e assim vai todas as tabelas que você queira criar.

E você vai, a gente vai ter também um arquivo de dependências. Arquivos de dependências é o que vai permitir a gente conseguir fazer coisas como, ah, eu só quero permitir que usuários autenticados acessem a minha tela de ordens. Ah, eu quero conseguir para cada link desse aqui acessar o meu banco de dados e editar alguma coisa no meu banco de dados de uma forma eficiente, garantindo que se várias requisições chegarem ao mesmo tempo, o meu sistema vai conseguir ordenar e fazer primeira a primeira requisição e aí quando ela tiver demorando muito, ele vai fazer a segunda, porque o FPI ele funciona num processo assíncrono.

Se você reparar, todas as funções que a gente define das nossas rotas são funções assíncronas. Qual é a vantagem disso do Fest API? que o FPI ele costuma ser mais rápido para executar as coisas justamente por causa dos processos assíncronos.

Na prática, a gente vai falar muito mais sobre isso ao longo do projeto, mas na prática acontece é imagina que chega uma requisição no seu site, chega um pedido de algum usuário dentro do seu site. Quando esse pedido chega do usuário naquele site, pode ser que esse pedido de um usuário específico, aquela requisição, ela demore, por exemplo, 15 segundos para ser tratada, porque ela tá consultando uma informação no banco de dados, tá fazendo uma série de coisas. Em alguns momentos desses 15 segundos, pode ser que elas estejam só esperando alguma resposta.

O que que o seu sistema do FPI permite você fazer? Ele automaticamente faz isso. Ele pega esse tempo de espera e ao invés de simplesmente ficar esperando aqui antes de tratar a próxima requisição, ele já começa a tratar a próxima requisição e aí assim que ele tiver disponibilidade de novo, ele volta para tratar essa requisição.

Então o processo assíncrono permite com que você um quando várias pessoas acessam um site, ele consiga atender essas várias pessoas e que não, uma única requisição de uma única pessoa não fique travando todo mundo. Essa requisição de uma única pessoa, ela vai ser tratada de forma assíncrona, assim como todas as outras coisas, justamente para permitir que você queões mais demoradas não travem todo o processo do seu sistema. É mais ou menos isso.

A gente vai falar mais em detalhes ao longo do nosso projeto, beleza? Então, a gente vai ter o nosso arquivo de dependência, acho que vai ser muito importante pra gente conseguir fazer isso, e o nosso arquivo de esquemas, que justamente é o que vai criar as estruturas que o Fest API vai pedir para você fazer para justamente tornar um processo muito eficiente. O legal do Fest API é que ele é um dos principais ferramentas, a gente chama de framework, de criação de sites no Python, onde ele usa tipagem que não é um padrão do Python.

O que significa isso? Significa que o FPI ele parte do princípio que você vai dar as informações para ele em formatos padronizados. Então, que uma string vai ser uma string, que um uma um número, um número inteiro vai ser um número inteiro e assim vai.

Então, ele pede para você definir os tipos de variáveis que você for criar ao longo do seu sistema, porque você definir os tipos de variáveis que você vai criar ao longo do seu sistema torna o seu projeto todo mais leve, apesar de você ter que escrever um pouco mais linhas de código, a execução do seu sistema fica mais leve, mais rápida e evita qualquer tipo de problema que você tem. problemas de testes, por exemplo, de tipos de valores, como, ah, eu deveria fazer um teste para ver se o usuário tá me enviando aqui uma informação como string, quando ele deveria efetivamente estar me enviando uma string, não um número inteiro, esse tipo de coisa, o FSPA já faz esse tratamento para você automaticamente, além de criar a documentação da sua API de forma padronizada, nesse estilo aqui intuitivo e direto ao ponto. Se você não entende ele ainda não precisa se preocupar, a gente vai falar muito mais sobre isso ao longo do projeto, mas eu queria nessa aula só dar essa explicada geral no FPI, como que funciona um projeto backend no FI.

Obviamente você pode fazer essa segmentação toda aqui em pastas diferentes e tudo mais, mas no caso aqui vocês vão ver que a gente vai partir do 00 mesmo e vai começar a criar o nosso projeto. Mas eu queria dar esse briefing em geral de como é que funciona o projeto no FPI para vocês e a gente agora começa a criar o nosso projeto. Vamos lá.

Bom galera, agora a gente vai começar efetivamente a construir o nosso projeto. Eu tô aqui com o VS Code aberto, tá? Não tem nada instalado nele.

A gente só tem aqui um ambiente virtual onde a gente vai criar os nossos códigos, onde a gente vai instalar as nossas bibliotecas e tudo mais. E aqui eu vou criar um arquivo inicial que vai ser o nosso arquivo main. pon que vai ser o arquivo inicial do nosso projeto.

Beleza? Vou dar um zoom aqui para ficar mais fácil de vocês visualizarem. E vamos lá, vamos começar.

Primeira coisa que eu vou fazer é que eu vou instalar aqui essencialmente todas as bibliotecas que a gente vai precisar para esse projeto, tá? Eu vou deixar disponível para vocês um arquivo de requirements aqui embaixo, que foram as versões que eu usei de todos os as bibliotecas que a gente instalou aqui, vai usar ao longo de todo o projeto. Vocês quiserem usar a mesma versão do que eu, é só vocês instalarem pelo arquivo de requirements, mas eu vou fazer a instalação dela aqui manualmente também, beleza?

Então o que a gente vai fazer, a gente vai abrir aqui o nosso terminal. Eu vou abrir aqui um comando prompt e vou garantir que ele tá com o meu ambiente virtual selecionado. Estando selecionado, vamos lá, vamos fazer as instalações.

Então, a gente vai fazer algumas instalações aqui. A gente vai fazer a instalação do Fast API, que é justamente o cara que a gente vai usar para fazer o nosso projeto como todo. A gente vai usar o UVCorn.

O UVCorn é o que a gente chama de uma ASDI server, né? Basicamente o que que é isso daqui? Ele é um gerenciador do nosso servidor que permite você gerenciar requisições que acontecem de forma síncrona, né?

Basicamente é mais um usuário tentando acessar o seu sistema ao mesmo tempo. Como que ele gerencia essas diferentes requisições? Você precisa de um sistema desse, no caso do Festpi, a gente vai usar o Ubicorn para fazer isso, tá bom?

Inclusive para poder testar dentro da nossa máquina. Então, a gente vai precisar instalar o corn. Para isso, a gente vai instalar aqui o SQL Alkim para poder fazer a criação do nosso banco de dados e a estrutura de modelos do nosso banco de dados que vão se traduzir em tabelas efetivamente dentro do banco.

Então, o SQL al é o cara que permite a gente fazer isso de uma forma e estruturada, mais simples e tudo mais. A gente vai instalar aqui também o PS LIB, mas a gente não vai instalar o PS lib na instalação padrão dele. A gente vai passar aqui para ele dentro de colchetes o parâmetro decryption.

O que que esse cara permite a gente fazer? Ele permite a gente criptografar de nossas senhas de uma forma segura. Então, toda senha que a gente for armazenar dentro do banco de dados, ela vai estar criptografada para, inclusive, se alguma pessoa qualquer der uma olhada no seu banco de dados, ela nunca saber a senha de alguém que tá ali.

Essa é a forma correta que você faz dentro de um projeto backend de armazenar senhas no banco de dados. Então, para isso a gente vai precisar do PS Liv para fazer esse processo todo instalando o pacote Becrypt dele. Então, é só você passar PIB e entre cchetes BCPT.

Repara que o nome de cada biblioteca tá separado só para um espaço mesmo, tá? É só isso que você precisa para fazer a instalação de todas elas. Além disso, a gente vai precisar instalar o Python traço rosé, tá?

Python traço Jos. O que que é esse cara daqui? Instalando dele o pacote do Cryptography.

Cryptography. O que que é esse cara daqui? Esse cara daqui é o que vai permitir a gente criar os nossos token JWT.

O que que são os tokens JWT? Basicamente, quando você consome uma API, você pode criar um sistema de autenticação na API. Quando você cria um sistema de autenticação na API, você pode pedir para usuário sempre que quiser fazer autenticação no seu sistema, ele mandar um e-mail e uma senha.

e você pega essa informação e verifica aquilo dali, se tá batendo com e-mail, sem que tá armazenado no seu banco de dados. Esse é um processo que você pode fazer. O problema é que não é muito seguro você a cada requisição ficar trocando e-mail o tempo todo.

Então, normalmente o que que a gente faz? a gente cria um token onde dentro desse token ele é essencialmente uma série de caracteres, mas dentro dele tem algumas informações ali embedadas, que são as informações que são embedadas no formato Jon e só que criptografado. Então por isso que é JWT a sigla que a gente usa, que significa Jason Web token.

Tudo isso que eu tô falando para vocês, galera, quando a gente for usar essas coisas, a gente vai falar de novo, a gente vai relembrar. Eu tô só querendo dar um panorama inicial de tudo que a gente tá instalando, só para não tacar as instalações aqui, vocês acharem que eu tô fazendo coisa aleatória, tá? Então o Python Rosé é justamente o cara que vai permitir a gente criar esses tokens e gerenciar esses tokens e distrair informações dele, pegar informações e colocar dentro desses web tokens e assim vai.

Ele é o cara que vai permitir a gente fazer isso. Além disso, a gente vai precisar do Python. Para gerenciar o nosso arquivo de variáveis de ambiente, que é um processo bem padrão que a gente vai ter todos os nossos eh todos os nossos tokens mesmo, porque a gente precisar do nosso sistema, chaves secretas, informações, elas vão estar armazenadas de forma segura dentro das nossas variáveis de ambiente.

Por isso que a gente vai usar o python. para fazer isso. E a gente também vai precisar do Python Multiparts.

A princípio ela é instalada junto com Python Rosé, mas eu tive problemas na hora que eu tava construindo o projeto quando eu não fiz a instalação dela de forma direta. Ela é uma dependência do Python rosé, mas a gente tá instalando então ela manualmente justamente pra gente não ter esse tipo de problema ao longo do nosso projeto. Bom, esse aqui é essencialmente o que a gente vai precisar de instalar.

Se acabar surgindo alguma outra coisa ao longo do caminho, a gente faz a instalação. Mas isso aqui é essência do que a gente precisa. Então vou dar um enter aqui e ele vai fazer toda essa instalação pra gente.

Beleza? Terminada essa instalação toda, eu vou cortar para pedaço da aula onde a gente já terminou toda essa instalação. A gente vai começar a criar o nosso primeiro projeto pra gente colocar o nosso a nossa API da FPI já no ar nessa aula mesmo.

Pronto, fez a instalação toda aqui. Vamos lá, vamos colocar agora essa API no ar. Sempre que a gente quiser colocar essa API no ar, a gente vai precisar executar aqui um comando.

E que comando é esse que a gente vai precisar executar? Esse comando sempre vai ser aqui no nosso terminal, tá? Ele vai ser UVCorn, que é justamente o cara que a gente instalou, né, o nosso servidor UVCorn.

main dois pontos app traço traço reload. O que que é esse comando que ele tá dizendo aqui? Porque esses nomes aqui e o Vicorn é justamente o cara.

A gente vai rodar isso aqui. Então sempre que a gente quiser colocar no ar aqui dentro do nosso terminal. Se eu rodar agora não vai acontecer nada porque no nosso código não tem nada acontecendo.

Mas o que que isso aqui tá dizendo? Tá dizendo, olha só, eu vou criar um servidor usando o cororn e eu vou executar o aplicativo main. Eu vou executar o arquivo main.

Então o arquivo main, esse arquivo que a gente criou aqui chamado main. Se eu tivesse chamado ele de meu aplicativo, aqui seria meu aplicativo ao invés de main. Como eu chamei ele de main, que é o aqui, esse aqui, arquivo main é o arquivo onde eu vou criar o nosso app, a nossa variável app, que é a nossa variável do FPI.

Então esse nome app aqui é a variável do FPI que a gente vai criar dentro desse arquivo main agora. Então tá falando, olha, eu vou pegar esse arquivo main que você criou e vou colocar dentro do meu servidor UVCorn a variável app que você vai criar. Eu vou deixar isso daqui eh como um comentário.

Vou dizer aqui, ó, para rodar o nosso código, executar no terminal. A gente vai executar no terminal esse comando daqui. Beleza?

Então agora eu vou chegar aqui e vou importar. Então vou fazer assim, ó. From fast, import fast API.

Deixa eu dar um zoom aqui para vocês verem melhor. Esse daqui basicamente é o cara que a gente vai criar o nosso app, que a gente vai criar agora o nosso app, que vai ser uma instância dessa classe FPI. É assim que você cria o seu aplicativo do Fast API.

Beleza? Então, no nosso arquivo main, em teoria, isso aqui é tudo que você precisaria eh de configuração básica super inicial, mas para você poder ver alguma coisa quando você rodar esse comando daqui, porque olha só, se eu pegar esse código aqui agora e rodar, olha só o que que vai acontecer. Pegar esse código, vou rodar.

Ele rodou, ele colocou o meu sistema no ar, tá vendo? Ele não deu erro nenhum, ele colocou o meu sistema no ar. Só que se eu entrar nesse link que tá aqui disponível, olha lá, vou trazer aqui pra nossa tela.

Se eu entrar nesse link, ele vai falar: "Não tem nada aqui". E mas o legal é que você já consegue perceber que o FP conseguiu fazer a configuração dele. Por quê?

Porque já tá vindo uma resposta num formato aqui. Tá vendo, ó? Detail not found.

Ele não encontrou nada. E se eu entrar aqui no barra dots, que é o que o PSPI cria pra gente automaticamente, ele já vai, deixa eu ajustar o zoom aqui, ele já vai criar pra gente, olha lá, um título de F API que você não definiu nada ainda na sua operação. Então, com isso, você colocou o seu, você criou o seu aplicativo do Fest API.

Resumo, sempre que você quiser criar um aplicativo do Fest API, você vai precisar instalar o Fest API, chamar uma instância da classe eh FPI para criar o seu aplicativo e depois no seu código do UVCorner você usar o nome do seu aplicativo e o nome da variável da instância do FPI que você criou aqui, chamando ele. Esse parâmetro reload é porque toda edição que a gente fizer agora no nosso projeto, eu não preciso pausar o nosso projeto todo e colocar ele no ar de novo, porque quando você roda esse comando e ele tá aqui na descrição, olha lá, quando você roda, ele fica aqui rodando o tempo todo. Então agora toda a alteração que eu fizer no nosso projeto, eu não preciso vir aqui, pausar, olha lá, ele fala: "Se você apertar contrtrl C, você pausa, você fecha.

Então, se eu apertar aqui, clicar aqui no terminal, apertar contrtrl C, ele fecha o meu aplicativo e eu tenho que rodar o comando de novo dov para ele colocar meu aplicativo no ar de novo. Mas como eu passei esse parâmetro reload, você não precisa fazer isso. Sempre que você salvar esse arquivo aqui dentro do seu projeto do FPI, ele automaticamente aqui vai fazer o reload e aí você vai lá dar um F5 dentro da sua tela do do seu navegador, né, aqui no nosso navegador e você vai conseguir ver as alterações que ele fizer aqui.

Vai só simplesmente dando um F5. Beleza? Agora, a partir da próxima aula, a gente vai começar a criar as nossas rotas, que é justamente o próximo passo que eu tenho que fazer aqui.

Depois de você configurar, então, a criação padrão do seu FCPI, agora você tem que criar rotas ali dentro dele para ele poder criar esses primeiros end points, primeiros links e depois vai simplesmente evoluindo o que que esses end points conseguem fazer, o que esses links conseguem fazer para criar banco de dados, da autenticação e tudo mais. Beleza? Então vamos lá.