Passaporte Laravel: um tutorial e um exemplo de compilação

Introdução

Laravel Passport é uma maneira fácil de configurar um sistema de autenticação para sua API. Como um pacote Laravel, ele usa um servidor OAuth2 para realizar a autenticação, criando tokens para aplicativos de usuário que solicitam interface com a API que ele protege, e apenas conceder-lhes acesso se seus tokens forem validados.

Neste artigo, construiremos uma API que interage com nosso banco de dados e processa os dados dos funcionários. A API será protegida usando o Passport, que permitirá o acesso a certas informações protegidas apenas quando um token de acesso for fornecido.

Autenticação em APIs REST

APIs REST se tornaram a espinha dorsal das plataformas da web e do processamento de dados. Isso ocorre porque eles incentivam a flexibilidade e a escalabilidade. Com uma API REST controlando o back-end de um aplicativo, todos os tipos de aplicativos cliente podem fazer interface com ele, independentemente do idioma em que são escritos. Dessa forma, um aplicativo da web pode atender a uma ampla variedade de usuários.

Uma desvantagem das APIs REST é que elas não têm estado. Em outras palavras, os estados do aplicativo não são mantidos no lado do servidor. Não há sessões para controlar os estados, como se um usuário está ou não conectado. Uma das razões para isso é que pedir ao servidor para armazenar as sessões de talvez milhões de usuários iria sobrecarregá-lo, levando a gargalos de desempenho e dificultando a escalabilidade.

E assim, com as APIs REST, torna-se responsabilidade do aplicativo cliente armazenar suas próprias informações e fornecer ao servidor todas as informações de que ele precisa sempre que uma solicitação é feita. Essa transferência de estado constante é o que o”ST”em”REST”significa.

Em vez de servidores economizando estados e consumindo muito tempo e espaço, com APIs REST, os aplicativos cliente são fornecidos com credenciais a serem enviadas ao servidor com cada solicitação. Essa credencial geralmente é chamada de token de autorização. O servidor valida esse token e, em seguida, dá ao aplicativo cliente acesso aos recursos necessários. Este processo é chamado de autenticação.

Por que a autenticação é importante? APIs fornecem acesso às informações armazenadas em seu banco de dados-provavelmente informações confidenciais às quais você não deseja necessariamente que o público em geral tenha acesso. Você precisa de uma maneira de verificar se o usuário que está tentando acessar suas informações tem permissão. É aqui que entra a autenticação.

O que você construirá

Ao final deste tutorial, você terá construído uma API segura que pode ser usada para:

• Registre funcionários
• Solicite uma lista de todos os funcionários
• Solicite os detalhes de um determinado funcionário
• Alterar os detalhes de um funcionário
• Exclua os detalhes de um funcionário

Estes são os detalhes do funcionário a serem salvos no banco de dados:

• Nome
• Idade
• Trabalho
• Salário

Pré-requisitos

Para acompanhar este tutorial, você deve ter o seguinte:

• PHP, MySQL e Apache instalados. Uma simples instalação do Xampp deve cuidar de tudo isso
• Composer instalado
• Laravel instalado, junto com um conhecimento básico desta estrutura
• Postman , para testar as APIs que criamos

Passo 1-Criando um novo aplicativo Laravel

Existem duas maneiras de criar um scaffold para um novo aplicativo no Laravel. Para usar o instalador do Laravel, execute:

  laravel novo nome de aplicativo
 

Para usar o composer em vez disso, execute:

  compositor criar-projeto--prefer-dist laravel/laravel nome-do-aplicativo
 

Se você quiser verificar o padrão que vem com um projeto Laravel recém-criado, navegue até o diretório do projeto que você acabou de criar e execute:

  php artisan serve
 

Abra seu navegador da web e digite o seguinte url: http://localhost: 8000

Agora que temos um aplicativo instalado e funcionando, precisamos conectá-lo a um banco de dados. Crie um banco de dados para seu aplicativo e adicione os valores apropriados para as seguintes variáveis ​​em seu arquivo .env :

DB_DATABASE
DB_USERNAME
DB_PASSWORD

Com nosso banco de dados configurado, podemos prosseguir com a configuração do Passport em nosso aplicativo.

Etapa 2-Instalação e configuração do Passport

O Passport implementa autenticação OAuth2 em nosso aplicativo. Ele gera um token exclusivo para cada usuário autenticado, de modo que cada solicitação enviada à API para acessar rotas protegidas será acompanhada por esse token. Para instalar o Passport with Composer, execute o seguinte comando:

  compositor requer laravel/passaporte
 

O Passport precisará armazenar clientes OAuth2 e tokens de acesso em algumas tabelas do banco de dados, para que ele crie migrações para as tabelas durante a instalação. Migre seu banco de dados para criar as tabelas:

  migração artesanal de php
 

Para gerar tokens de acesso seguro para sua aplicação, o Passport requer algumas chaves de criptografia e dois clientes conhecidos como Laravel Personal Access Client e Laravel Password Grant Client. Para criar essas chaves e clientes de criptografia, execute o seguinte comando:

  passaporte php artisan: instalar
 

Para acessar certas rotas protegidas em nosso aplicativo, nossos usuários precisarão se registrar e fazer o login. Não se preocupe, os novos aplicativos Laravel vêm com um modelo de Usuário e arquivo de migração de usuários pronto para uso. Isso será suficiente para nossas necessidades.

Você precisará inspecionar todos os tokens e escopos de usuários autenticados. O atributo HasApiTokens fornecerá alguns métodos auxiliares para realizar isso. Para adicioná-lo ao seu modelo User , navegue até App \ Models \ User , adicione seu namespace na parte superior e especifique para ser usado dentro do User classe :

 
 O Passport vem com algumas rotas usadas para emitir e revogar tokens de acesso. Para registrar essas rotas, você precisa chamar o método  Passport:: routes  dentro do método de inicialização em seu  AuthServiceProvider . Navegue até  App \ Providers \ AuthServiceProvider  e atualize-o. 
 No Laravel,  Políticas  são usadas para proteger recursos de acesso não autorizado. Como algumas de nossas rotas precisarão ser protegidas e precisarão de tokens de acesso para serem acessados, usaremos as  Políticas . 
 Dentro da matriz  $ policies , comente esta linha: 'App \ Models \ Model'=>'App \ Policies \ ModelPolicy' para torná-la disponível para uso: 

 'App \ Policies \ ModelPolicy',//descomente ]; /** * Registre quaisquer serviços de autenticação/autorização. * * @return void */ inicialização de função pública () { $ this-> registerPolicies (); Passaporte:: rotas ();//Registrar rotas de passaporte // }
}

 Seu aplicativo precisa usar o  TokenGuard  do Passport para autenticar as solicitações de entrada da API. Para configurar isso, navegue até o arquivo  config/auth.php , vá para o protetor de autenticação  api  e defina o valor do  driver  opção para  passaporte : 
'guardas'=> [ 'web'=> [ 'driver'=>'sessão', 'provedor'=>'usuários', ], 'api'=> [ 'driver'=>'passaporte',//atualize esta linha 'provedor'=>'usuários', ],
],

 Etapa 3-Criação de um modelo e um arquivo de migração para funcionários 
 Para criar um banco de dados para armazenar as informações de nossos funcionários, criaremos um modelo de funcionário e um arquivo de migração usando o comando artesão abaixo: 
  php artisan make: model Employee-m
 
 O comando  make: model  criará o novo modelo dentro da pasta  app . O sinalizador -m  criará o novo arquivo de migração dentro de sua pasta  banco de dados/migrações . 
 Agora, vamos prosseguir com a criação da tabela do banco de dados de nossos funcionários. Navegue até  banco de dados/migrações , abra seu arquivo  create_employees_table  recém-criado e adicione as colunas apropriadas para todas as informações de funcionários que iremos armazenar (nome, idade, trabalho e salário): 
  id (); $ tabela-> string ('nome'); $ tabela-> string ('idade'); $ table-> string ('job'); $ tabela-> string ('salário'); $ table-> timestamps (); }); } /** * Reverta as migrações. * * @return void */ função pública desativada () { Esquema:: dropIfExists ('funcionários'); }
}

 A seguir, vamos alinhar nosso modelo  Funcionário  com nosso arquivo de migrações acima: 
 
 Para criar a tabela para a qual acabamos de criar o arquivo de migração acima, execute o comando abaixo: 
  migração artesanal de php
 
 Se você verificar seu banco de dados agora, deverá ver a tabela de funcionários com todos os campos que especificamos. 
 Etapa 4-Criação de nossos controladores 
 Antes de criarmos o controlador que tratará dos detalhes dos funcionários, vamos criar o controlador que permitirá aos usuários se registrar, fazer login e usar nosso aplicativo. 
 Use o comando abaixo para criá-lo (vamos chamá-lo de  UserAuthController  e criar uma nova pasta para ele chamada  Auth ): 
 php artisan make: controlador Auth/UserAuthController

 Você pode encontrar o controlador recém-criado em  app/Http/Controllers/Auth . Vamos continuar criando os métodos de registro e login de que precisamos: 

  validate ([ 'nome'=>'necessário | máx: 255', 'email'=>'obrigatório | email | exclusivo: usuários', 'senha'=>'necessária | confirmada' ]); $ data ['senha']=bcrypt ($ solicitação-> senha); $ user=User:: create ($ data); $ token=$ user-> createToken ('API Token')-> accessToken; resposta de retorno (['usuário'=> $ usuário,'token'=> $ token]); } login de função pública (solicitação $ solicitação) { $ data=$ pedido-> validate ([ 'email'=>'email | obrigatório', 'senha'=>'necessária' ]); if (! auth ()-> tentativa ($ data)) { resposta de retorno (['error_message'=>'Detalhes incorretos. Por favor, tente novamente']); } $ token=auth ()-> user ()-> createToken ('API Token')-> accessToken; resposta de retorno (['usuário'=> auth ()-> usuário (),'token'=> $ token]); }
}

 Agora temos um método de registro para criar novos usuários para nosso aplicativo. 
 Usando o método  validate ()  do Laravel, garantimos que o campo do nome seja preenchido e que o valor inserido não exceda 255 caracteres. Também garantimos que um e-mail seja inserido para registro e que seja único. 
 Usamos a função  bcrypt  do Laravel para hash a senha do usuário, como  não é seguro armazenar suas senhas como texto simples . Se todos os requisitos de registro que definimos forem atendidos, uma nova conta de usuário é criada, um token de acesso é gerado e os detalhes do novo usuário, junto com seu token de usuário, são retornados como resposta. 
 Para o método de login, usamos o método  validate ()  do Laravel novamente para garantir que um e-mail e uma senha sejam fornecidos. O método  auth () → try ()  tenta fazer o login do usuário com os detalhes que ele forneceu. Se os detalhes não forem iguais aos com os quais foram registrados, uma mensagem de erro será exibida, solicitando que eles tentem novamente. Se os detalhes estiverem corretos, um token de acesso é criado e o usuário está logado-agora pronto para acessar nossas rotas protegidas. 
 Para acessar qualquer rota protegida, o token de acesso criado deverá ser passado junto com a solicitação HTTP, sinalizando para nosso aplicativo que o usuário está autorizado a acessar recursos privados. 
 O controlador que processará os dados do funcionário retornará respostas no formato JSON. Uma vez que iremos retornar principalmente instâncias de modelo e coleções de instâncias de modelo, podemos usar os  Recursos de API  do Laravel Eloquent. Se um usuário solicitar uma lista de funcionários, podemos usar  resource  para enviar o modelo de funcionário de volta como resposta, no formato JSON. Se um usuário solicitar os detalhes de um funcionário, podemos usar  resource  para enviar essa instância de modelo específica de volta. 
 Então, vamos prosseguir e criar um arquivo  Resource  para nosso modelo  Employee : 
 php artisan make: resource EmployeeResource

 Agora, se precisarmos enviar detalhes dos funcionários como resposta a uma chamada de API, podemos usar  EmployeeResource  para enviá-los no formato JSON (na forma de um array). A vantagem disso é que todos os tipos de aplicativos cliente (Flutter, Angular, React etc.) podem processar dados JSON facilmente. 
 As solicitações HTTP de entrada que nosso aplicativo receberá serão processadas por um controlador que chamaremos de controlador do funcionário. Os métodos neste controlador retornarão as respostas apropriadas às solicitações HTTP no formato JSON: 
 php artisan make: controller EmployeeController--api--model=Employee

 O sinalizador --api  nos ajuda a criar os cinco métodos que são  comumente usado  para realizar operações em recursos: indexar, armazenar, mostrar, atualizar e destruir. O sinalizador --model  significa que o controlador que estamos criando é para o modelo  Employee  e nos permite usar  vinculação do modelo de rota  no controlador. 
 Agora que temos um controlador, vamos começar a criar os métodos de que precisamos para processar os dados dos funcionários. Navegue até o seu controlador recém-criado  app/Http/Controllers/EmployeeController.php  e abra-o: 
? php namespace App \ Http \ Controllers; use App \ Models \ Employee;
use App \ Http \ Controllers \ Controller;
use App \ Http \ Resources \ EmployeeResource;
use Illuminate \ Http \ Request;
use Illuminate \ Support \ Facades \ Validator; classe EmployeeController extends Controller
{ /** * Exibir uma lista do recurso. * * @return \ Illuminate \ Http \ Response */ índice de função pública () { $ funcionários=Funcionário:: todos (); resposta de retorno (['funcionários'=> EmployeeResource:: collection ($ funcionários), 'mensagem'=>'Sucesso'], 200); } /** * Armazene um recurso recém-criado no armazenamento. * * @param \ Illuminate \ Http \ Request $ request * @return \ Illuminate \ Http \ Response */ armazenamento de função pública (solicitação $ solicitação) { $ data=$ solicitação-> all (); $ validator=Validator:: make ($ data, [ 'nome'=>'necessário | máx.: 50', 'idade'=>'necessário | máx: 50', 'job'=>'necessário | máx: 50', 'salário'=>'necessário | 50' ]); if ($ validator-> fail ()) { resposta de retorno (['erro'=> $ validator-> erros (), 'Erro de validação']); } $ funcionário=Funcionário:: criar ($ dados); resposta de retorno (['funcionário'=> novo EmployeeResource ($ employee), 'mensagem'=>'Sucesso'], 200); } /** * Exibe o recurso especificado. * * @param \ App \ Employee $ employee * @return \ Illuminate \ Http \ Response */ show de função pública (funcionário $ funcionário) { resposta de retorno (['funcionário'=> novo EmployeeResource ($ employee),'message'=>'Sucesso'], 200); } /** * Atualize o recurso especificado no armazenamento. * * @param \ Illuminate \ Http \ Request $ request * @param \ App \ Employee $ employee * @return \ Illuminate \ Http \ Response */ atualização de função pública (solicitação $ solicitação, funcionário $ funcionário) { $ employee-> update ($ request-> all ()); resposta de retorno (['funcionário'=> novo EmployeeResource ($ employee),'message'=>'Sucesso'], 200); } /** * Remova o recurso especificado do armazenamento. * * @param \ App \ Employee $ employee * @return \ Illuminate \ Http \ Response * @throws \ Exception */ destruição de função pública (funcionário $ funcionário) { $ funcionário-> delete (); resposta de retorno (['mensagem'=>'Funcionário excluído']); }
}

 O método  index  acima obtém os detalhes de todos os funcionários em nosso banco de dados e os retorna no formato JSON, usando  Recursos . Usamos o método  store  para adicionar os detalhes de um novo funcionário ao banco de dados. Usando o Validador do Laravel, garantimos que as informações de todas as colunas em nossa tabela de funcionários sejam fornecidas. Em seguida, retornamos os detalhes do novo funcionário no formato JSON. 
 O método  show  busca os detalhes de um funcionário específico e os retorna como uma resposta JSON. Aqui, não precisamos escrever código para consultar o banco de dados com um ID de funcionário específico porque estamos utilizando  vinculação do modelo de rota . 
 O método  update  envia novas informações para um funcionário existente. Em seguida, ele atualiza o registro do funcionário no banco de dados com essas novas informações e retorna as informações como resposta no formato JSON. Assim como com o método  show , não precisamos escrever código para consultar o banco de dados com um ID de funcionário específico, pois estamos utilizando  vinculação do modelo de rota . Isso é feito automaticamente. 
 O método  destroy  simplesmente exclui os detalhes de um funcionário existente do banco de dados e retorna uma mensagem de sucesso. 
 Etapa 5-Criando nossas rotas 
 A seguir, vamos criar as rotas (endpoints) que serão responsáveis ​​por responder às solicitações HTTP e redirecioná-las aos métodos apropriados para processá-las e retornar uma resposta. Navegue até  routes/api.php  e atualize-o: 
 Route:: post ('/register','Auth \ UserAuthController @ register');
Route:: post ('/login','Auth \ UserAuthController @ login'); Route:: apiResource ('/employee','EmployeeController')-> middleware ('auth: api');

 A primeira rota acima aponta para o método de registro que criamos dentro de nosso  UserAuthController . Agora, quando este endpoint é chamado, nosso método  register  é acionado e um novo usuário é criado. A segunda rota aponta para nosso método  login , que é para o login de usuários. 
 A terceira rota aponta para todos os métodos que serão responsáveis ​​pelo processamento dos dados dos funcionários. Como nosso aplicativo é uma API que simplesmente fornece pontos de extremidade a serem chamados,  não precisamos de rotas e métodos para Modelos HTML , como  create  e  edit . Usando o método  apiResource  acima, podemos excluir essas duas rotas automaticamente e apenas criar rotas como index, store, show, update e destroy. Essas 5 rotas são representadas pelo método  apiResource  e estão apontando para os 5 métodos correspondentes no controlador  Employee  que criamos acima. 
 Usamos o Passport para  proteger essas rotas  adicionando o  auth: api  middleware para eles. Agora, um token de acesso válido será necessário para qualquer chamada feita para qualquer uma dessas rotas. 
 E pronto! Para testar seu aplicativo, execute o seguinte comando: 
  php artisan serve
 
 Usarei o Postman para testar meus endpoints de API. Você pode usar qualquer software com o qual se sinta confortável. 
 Criar novo usuário 
 Nosso ponto final para criar um novo usuário é  http://localhost: 8000/api/register . Usando uma solicitação POST, forneça um nome, e-mail e senha conforme mostrado abaixo. 
  
 Login de usuário 
 Agora podemos fazer o login do usuário que acabamos de criar usando este endpoint:  http://localhost: 8000/api/login . 
  
 Adicionar novo funcionário 
 Podemos adicionar um novo funcionário ao nosso banco de dados enviando seu nome, idade, trabalho e salário para este endpoint:  http://localhost: 8000/api/employee . 
 Como este é um endpoint protegido, certifique-se de copiar o token de acesso que você recebeu ao fazer login, clique na guia de autorização no Postman, selecione Bearer Token na lista suspensa Tipo e cole seu token dentro do Token campo. 
  
 Obtenha uma lista de funcionários 
 Você pode obter a lista de funcionários de seu banco de dados usando este endpoint:  http://localhost: 8000/api/funcionário . Desta vez, usamos uma solicitação GET. 
  
 Obtenha detalhes do funcionário 
 Para obter os detalhes de um determinado funcionário, usamos o seguinte endpoint:  http://localhost: 8000/api/employee/1 . Aqui, “1” deve ser alterado para a ID específica do funcionário. 
  
 Atualizar os dados do funcionário 
 Para atualizar os detalhes de um funcionário, preencha os novos dados e envie uma solicitação PATCH para  http://localhost: 8000/api/employee/1  (certifique-se de usar o ID apropriado). 
  
 Excluir um funcionário 
 Para excluir os detalhes de um funcionário, envie uma solicitação DELETE para  http://localhost: 8000/api/funcionário/1  (certifique-se de usar o ID apropriado). 
  
 Conclusão 
 Em 5 etapas, criamos uma API REST e a protegemos com o Laravel Passport. Para saber mais sobre como usar o Passport, você pode verificar a  documentação oficial  aqui. Há também um  repositório Github para o projeto  que construímos neste tutorial, caso você precise. 
 O post  Passaporte Laravel: Um tutorial e compilação de exemplo  apareceu primeiro no  LogRocket Blog . 
 Source link