Slim Framework Criando Microservices 07 Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme

Prévia do material em texto

17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 1/18
Slim Framework — Criando Microservices 07—
Implementando Segurança Básica com HTTP Auth,
JWT, e Proxy Scheme
Matheus Fidelis
May 3, 2017 · 4 min read
Bom dia pessoal! Estamos quase chegando ao fim da nossa série de artigos sobre Slim
Framework. Estamos com o nosso microservice de CRUD de livros quase completo.
Hoje vamos falar um pouco sobre implementações de segurança.
Slim Framework — Criando Microservices 01 — Composer e Dependências
Slim Framework — Criando Microservices 02 — Implementando métodos e
Responses HTTP
Slim Framework — Criando Microservices 03 — Camada de Persistência com
Doctrine e Entity Manager
Slim Framework — Criando Microservices 04 — CRUD completo via API com
Doctrine
Slim Framework — Criando Microservices 05 — Validações e Exceptions na
API
Slim Framework — Criando Microservices 06 — Middlewares, Logging e
HTTP Errors Fallback
https://medium.com/p/8b45bd6ce85c/edit
https://medium.com/@fidelissauro?source=post_page-----ed6dd6d517f4----------------------
https://medium.com/@fidelissauro?source=post_page-----ed6dd6d517f4----------------------
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-seguran%C3%A7a-b%C3%A1sica-com-http-auth-e-proxy-ed6dd6d517f4?source=post_page-----ed6dd6d517f4----------------------
https://medium.com/@fidelissauro/slim-framework-criando-microservices-01-composer-e-depend%C3%AAncias-f9c8b8798205
https://medium.com/@fidelissauro/slim-framework-criando-microservices-02-implementando-m%C3%A9todos-e-responses-http-708570fa748d
https://medium.com/@fidelissauro/slim-framework-criando-microservices-03-camada-de-persist%C3%AAncia-com-doctrine-e-data-mapping-a15df5483bc2
https://medium.com/@fidelissauro/slim-framework-criando-microservices-04-crud-completo-via-api-com-doctrine-13e839432610
https://medium.com/@fidelissauro/slim-framework-criando-microservices-05-valida%C3%A7%C3%B5es-e-exceptions-na-api-fd1f48087a2d
https://medium.com/@fidelissauro/slim-framework-criando-microservices-06-middlewares-logging-e-http-errors-fallback-8b45bd6ce85c
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 2/18
Autenticação básica com HTTP Auth
Vamos trabalhar primeiro com uma autenticação básica via HTTP. Essa autenticação
funciona via usuário e senha. Vamos usar ela para nos dar um JWT válido no final.
Primeiro vamos instalar a biblioteca.
$ composer require tuupola/slim-basic-auth
Vamos criar uma rota de autenticação.
index.php
Agora vamos adicionar um Middleware e criar uma HTTP basic Auth para essa rota que
acabamos de criar com a biblioteca que adicionamos. Vamos proteger somente a rota
/auth. As outras serão protegidas pelo Json Web Token, então não se preocupe. Nosso
usuário de teste será root e senha toor (vulgo root ao contrário). Faremos isso de uma
forma mais inteligente quando entrarmos no ponto de escalar e containerizar nosso
Microserviço.
bootstrap.php
view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
authhttpbasicindex01.php hosted with ❤ by GitHub
<?php 
//..
/**
 * HTTP Auth - Autenticação minimalista para retornar um JWT
 */
$app->get('/auth', function (Request $request, Response $response) use ($app) {
 return $response->withJson(["status" => "Autenticado!"], 200)
 ->withHeader('Content-type', 'application/json'); 
});
//..
1
2
3
4
<?php
//..
https://gist.github.com/msfidelis/2c5debe2ec377b8ed1710f5941a87121/raw/cd6c0d97da1c1b0f0d1416bcdf3d9399edacecdf/authhttpbasicindex01.php
https://gist.github.com/msfidelis/2c5debe2ec377b8ed1710f5941a87121#file-authhttpbasicindex01-php
https://github.com/
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 3/18
Agora vamos testar nossa implementação. Podemos testar de duas formas, via
navegador e via cURL
Para dar falha na autenticação
$ curl -X GET http://localhost:8000/auth
Para validar a autenticação
$ $ curl -u root:toor -X GET http://localhost:8000/auth
view raw
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
bootstrapbasicauth01.php hosted with ❤ by GitHub
/**
 * Auth básica HTTP
 */
$app->add(new \Slim\Middleware\HttpBasicAuthentication([
 /**
 * Usuários existentes
 */
 "users" => [
 "root" => "toor"
 ],
 /**
 * Blacklist - Deixa todas liberadas e só protege as dentro do array
 */
 "path" => ["/auth"],
 /**
 * Whitelist - Protege todas as rotas e só libera as de dentro do array
 */
 //"passthrough" => ["/auth/liberada", "/admin/ping"],
]));
//..
https://gist.github.com/msfidelis/45bd8785edf063f6962cb623f1eb8ac3/raw/5654ecd50facccb785b77e92263cc2d337775e19/bootstrapbasicauth01.php
https://gist.github.com/msfidelis/45bd8785edf063f6962cb623f1eb8ac3#file-bootstrapbasicauth01-php
https://github.com/
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 4/18
Também podemos testar via Navegador quando a rota for GET
Autenticação com JWT (JSON Web Token)
Agora vamos pegar essa base simples de HTTP Auth que criamos uma nova camada de
autenticação Stateless na nossa API. Isso facilita escalabilidade, item que iremos
abordar mais a frente.
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 5/18
JSON Web Token — https://jwt.io/
Library para PHP — https://github.com/firebase/php-jwt
Library do Middleware — https://github.com/tuupola/slim-jwt-auth/
Gerando um JWT
Antes de protegermos as rotas, vamos começar a gerar um JWT simplificado na nossa
rota /auth que acabamos de criar. Para isso vamos precisar da biblioteca php-jwt
instalada. Então vamos lá para o Composer!
$ composer require firebase/php-jwt
No nosso bootstrap vamos criar uma variável dentro do nosso container ANTES de
criamos o new App();
bootstrap.php
Agora na nossa rota /auth, vamos cuspir um JSON Web Token gerado com essa secret
key. Vamos dar o use na library que acabamos de instalar do JWT, criar um array
qualquer com dados aleatórios de exemplo que vamos encriptar e validar com nossa
key e em seguida retornar via JSON caso a nossa HTTP Auth seja válida.
view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
authjsonwebtokenbootstrap.php hosted with ❤ by GitHub
<?php
///..
/**
 * Token do nosso JWT
 */
$container['secretkey'] = "secretloko";
/**
 * Application Instance
 */
$app = new \Slim\App($container);
//..
https://jwt.io/
https://github.com/firebase/php-jwt
https://github.com/tuupola/slim-jwt-auth/
https://gist.github.com/msfidelis/cb5dcf7d0b9916267ad4ce6d2d34e45d/raw/2e8d0bc8ab945b802e0956457e26189c34e4ddb5/authjsonwebtokenbootstrap.php
https://gist.github.com/msfidelis/cb5dcf7d0b9916267ad4ce6d2d34e45d#file-authjsonwebtokenbootstrap-php
https://github.com/
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 6/18
Agora novamentevamos testar com o usuário e senha.
view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
authjsonwebtokenindexauth.php hosted with ❤ by GitHub
<?php
//..
use Firebase\JWT\JWT;
//..
/**
 * HTTP Auth - Autenticação minimalista para retornar um JWT
 */
$app->get('/auth', function (Request $request, Response $response) use ($app) {
 $key = $this->get("secretkey");
 $token = array(
 "user" => "@fidelissauro",
 "twitter" => "https://twitter.com/fidelissauro",
 "github" => "https://github.com/msfidelis"
 );
 $jwt = JWT::encode($token, $key);
 return $response->withJson(["auth-jwt" => $jwt], 200)
 ->withHeader('Content-type', 'application/json'); 
});
//..
https://gist.github.com/msfidelis/18af1deb12a3cd01a18a6e09ffd0787a/raw/3b800470da913cd87b8c8a0808d5ffe76d65631d/authjsonwebtokenindexauth.php
https://gist.github.com/msfidelis/18af1deb12a3cd01a18a6e09ffd0787a#file-authjsonwebtokenindexauth-php
https://github.com/
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 7/18
Nosso retorno será parecido com o abaixo.
{
 "auth-jwt": 
"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyIjoiQGZpZGVsaXNzYXVyby
IsInR3aXR0ZXIiOiJodHRwczpcL1wvdHdpdHRlci5jb21cL2ZpZGVsaXNzYXVybyIsIm
dpdGh1YiI6Imh0dHBzOlwvXC9naXRodWIuY29tXC9tc2ZpZGVsaXMifQ.5TSgJhrZnID
Dnq9eXObFkDMGv8gw1yarErwAz9aZrwo"
}
Podemos validar nosso JWT com a chave no site do JWT para validar a assinatura.
Autenticando o restante da API com JWT
Para fazer a instalação vamos utilizar uma biblioteca vendor validada pela própria
comunidade da Slim.
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 8/18
$ composer require tuupola/slim-jwt-auth
No nosso bootstrap, vamos adicionar mais um middleware no nosso request. Nele
vamos definir no path toda nossa rota de API e adicionar nossa exceção de cobertura a
rota /auth que cobrimos com o Basic Auth que vai nos retornar o JWT para nos
autenticarmos no restante da API validando pela nossa secret key.
bootstrap.php
Testando
Nossos dados JWT são facilmente descriptografados, então é sempre bom não deixar
conteúdo sensível neles e sempre realizar um tráfego TLS. Quando trabalhos com
Microservices, normalmente eles ficam restritos dentro da nossa VPC ou Cluster, mas
esse tipo de autenticação é altamente recomendável para endpoints públicos.
Para testar, vamos realizar um request para qualquer ponto da nosso service de
gerenciamento de livros utilizando o token que acabamos de gerar. Qualquer caracter
diferente retornará um deny da API
view raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
bootstrapbasicauth02.php hosted with ❤ by GitHub
<?php
//..
/**
 * Auth básica do JWT
 * Whitelist - Bloqueia tudo, e só libera os
 * itens dentro do "passthrough"
 */
$app->add(new \Slim\Middleware\JwtAuthentication([
 "regexp" => "/(.*)/", //Regex para encontrar o Token nos Headers - Livre
 "header" => "X-Token", //O Header que vai conter o token
 "path" => "/", //Vamos cobrir toda a API a partir do /
 "passthrough" => ["/auth"], //Vamos adicionar a exceção de cobertura a rota /auth
 "realm" => "Protected", 
 "secret" => $container['secretkey'] //Nosso secretkey criado 
]));
https://gist.github.com/msfidelis/e932c2bf185defe98e5a945d49eb2712/raw/3c15fc016c5597c505c554070078a34f034dd39e/bootstrapbasicauth02.php
https://gist.github.com/msfidelis/e932c2bf185defe98e5a945d49eb2712#file-bootstrapbasicauth02-php
https://github.com/
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6d… 9/18
curl -X GET -H "X-
Token:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyIjoiQGZpZGVsaXNzY
XVybyIsInR3aXR0ZXIiOiJodHRwczpcL1wvdHdpdHRlci5jb21cL2ZpZGVsaXNzYXVyb
yIsImdpdGh1YiI6Imh0dHBzOlwvXC9naXRodWIuY29tXC9tc2ZpZGVsaXMifQ.5TSgJh
rZnIDDnq9eXObFkDMGv8gw1yarErwAz9aZrwoe" http://localhost:8000/book -
i
Protegendo nosso host para máquinas confiáveis do Cluster
Caso você esteja utilizando AWS, este passo faz o que hoje chamamos de Security
Group. Vamos fazer nossa API ser acessível apenas a alguns hosts determinados por
IP’s. Caso esteja rodando seu microservice dentro do cluster, talvez os outros dois
passos anteriores sejam opcionais.
Link do projeto: https://github.com/akrabat/rka-scheme-and-host-detection-
middleware
$ composer require akrabat/rka-scheme-and-host-detection-middleware
http://localhost:8000/book
https://github.com/akrabat/rka-scheme-and-host-detection-middleware
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 10/18
bootstrap.php
Nosso bootstrap até aqui:
view raw
1
2
3
4
5
6
7
8
9
bootstrapbasicauth03.php hosted with ❤ by GitHub
<?php
//..
/**
 * Proxys confiáveis
 */
$trustedProxies = ['09.89.12.23', '192.168.0.123'];
$app->add(new RKA\Middleware\SchemeAndHost($trustedProxies));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<?php
require './vendor/autoload.php';
use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\EntityManager;
use Psr7Middlewares\Middleware\TrailingSlash;
use Monolog\Logger;
use Firebase\JWT\JWT;
/**
 * Configurações
 */
$configs = [
 'settings' => [
 'displayErrorDetails' => true,
 ] 
];
/**
 * Container Resources do Slim.
 * Aqui dentro dele vamos carregar todas as dependências
 * da nossa aplicação que vão ser consumidas durante a execução
 * da nossa API
 */
$container = new \Slim\Container($configs);
/**
 * Converte os Exceptions Genéricas dentro da Aplicação em respostas JSON
https://gist.github.com/msfidelis/28f684f81d13721ee7656ddcb54fa5b6/raw/8550a7b6066f454ca85179584dc883f5d3975d30/bootstrapbasicauth03.php
https://gist.github.com/msfidelis/28f684f81d13721ee7656ddcb54fa5b6#file-bootstrapbasicauth03-php
https://github.com/
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 11/18
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 */
$container['errorHandler'] = function ($container) {
 return function ($request, $response, $exception) use ($container) {
 $statusCode = $exception->getCode() ? $exception->getCode() : 500;
 return $container['response']->withStatus($statusCode)
 ->withHeader('Content-Type', 'Application/json')
 ->withJson(["message" => $exception->getMessage()], $statusCode);
 };
};
/**
 * Converte os Exceptions de Erros 405 - Not Allowed
 */
$container['notAllowedHandler'] = function ($container) {
 return function ($request, $response, $methods) use ($container) {
 return $container['response']
 ->withStatus(405)
 ->withHeader('Allow', implode(', ', $methods))
 ->withHeader('Content-Type', 'Application/json')
 ->withHeader("Access-Control-Allow-Methods", implode(",", $methods))
 ->withJson(["message" => "Method not Allowed;Method must be one of: " . implode('
 };
};
/**
 * Converte os Exceptions de Erros 404 - Not Found
 */
$container['notFoundHandler'] = function ($container) {
 return function ($request, $response) use ($container) {
 return $container['response']
 ->withStatus(404)
 ->withHeader('Content-Type', 'Application/json')
 ->withJson(['message' => 'Page not found']);
 };
};
/**
 * Serviço de Logging em Arquivo
 */
$container['logger'] = function($container) {
 $logger = new Monolog\Logger('books-microservice');
 $logfile = __DIR__ . '/log/books-microservice.log';
 $stream = new Monolog\Handler\StreamHandler($logfile, Monolog\Logger::DEBUG);
 $fingersCrossed = new Monolog\Handler\FingersCrossedHandler(
 $stream, Monolog\Logger::INFO);
 $logger->pushHandler($fingersCrossed);
 
return $logger;
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 12/18
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 return $logger;
};
$isDevMode = true;
/**
 * Diretório de Entidades e Metadata do Doctrine
 */
$config = Setup::createAnnotationMetadataConfiguration(array(__DIR__."/src/Models/Entity"), $i
/**
 * Array de configurações da nossa conexão com o banco
 */
$conn = array(
 'driver' => 'pdo_sqlite',
 'path' => __DIR__ . '/db.sqlite',
);
/**
 * Instância do Entity Manager
 */
$entityManager = EntityManager::create($conn, $config);
/**
 * Coloca o Entity manager dentro do container com o nome de em (Entity Manager)
 */
$container['em'] = $entityManager;
/**
 * Token do nosso JWT
 */
$container['secretkey'] = "secretloko";
/**
 * Application Instance
 */
$app = new \Slim\App($container);
/**
 * @Middleware Tratamento da / do Request 
 * true - Adiciona a / no final da URL
 * false - Remove a / no final da URL
 */
$app->add(new TrailingSlash(false));
/**
 * Auth básica HTTP
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 13/18
Nosso index.php até aqui
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 */
$app->add(new \Slim\Middleware\HttpBasicAuthentication([
 /**
 * Usuários existentes
 */
 "users" => [
 "root" => "toor"
 ],
 /**
 * Blacklist - Deixa todas liberadas e só protege as dentro do array
 */
 "path" => ["/auth"],
 /**
 * Whitelist - Protege todas as rotas e só libera as de dentro do array
 */
 //"passthrough" => ["/auth/liberada", "/admin/ping"],
]));
/**
 * Auth básica do JWT
 * Whitelist - Bloqueia tudo, e só libera os
 * itens dentro do "passthrough"
 */
$app->add(new \Slim\Middleware\JwtAuthentication([
 "regexp" => "/(.*)/",
 "header" => "X-Token",
 "path" => "/",
 "passthrough" => ["/auth", "/admin/ping"],
 "realm" => "Protected",
 "secret" => $container['secretkey']
]));
/**
 * Proxys confiáveis
 */
$trustedProxies = ['0.0.0.0', '127.0.0.1'];
$app->add(new RKA\Middleware\SchemeAndHost($trustedProxies));
1
2
3
<?php
use \Psr\Http\Message\ServerRequestInterface as Request;
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 14/18
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
use \Psr\Http\Message\ResponseInterface as Response;
use App\Models\Entity\Book;
use Firebase\JWT\JWT;
require 'bootstrap.php';
/**
 * HTTP Auth - Autenticação minimalista para retornar um JWT
 */
$app->get('/auth', function (Request $request, Response $response) use ($app) {
 $key = $this->get("secretkey");
 $token = array(
 "user" => "@fidelissauro",
 "twitter" => "https://twitter.com/fidelissauro",
 "github" => "https://github.com/msfidelis"
 );
 $jwt = JWT::encode($token, $key);
 return $response->withJson(["auth-jwt" => $jwt], 200)
 ->withHeader('Content-type', 'application/json'); 
});
/**
 * Lista de todos os livros
 * @request curl -X GET http://localhost:8000/book
 */
$app->get('/book', function (Request $request, Response $response) use ($app) {
 $entityManager = $this->get('em');
 $booksRepository = $entityManager->getRepository('App\Models\Entity\Book');
 $books = $booksRepository->findAll();
 $return = $response->withJson($books, 200)
 ->withHeader('Content-type', 'application/json');
 return $return;
});
/**
 * Retornando mais informações do livro informado pelo id
 * @request curl -X GET http://localhost:8000/book/1
 */
$app->get('/book/{id}', function (Request $request, Response $response) use ($app) {
$ t $ t tAtt ib t (' t ')
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 15/18
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 $route = $request->getAttribute('route');
 $id = $route->getArgument('id');
 $entityManager = $this->get('em');
 $booksRepository = $entityManager->getRepository('App\Models\Entity\Book');
 $book = $booksRepository->find($id); 
 /**
 * Verifica se existe um livro com a ID informada
 */
 if (!$book) {
 $logger = $this->get('logger');
 $logger->warning("Book {$id} Not Found");
 throw new \Exception("Book not Found", 404);
 } 
 $return = $response->withJson($book, 200)
 ->withHeader('Content-type', 'application/json');
 return $return;
});
/**
 * Cadastra um novo <Livro></Livro>
 * @request curl -X POST http://localhost:8000/book -H "Content-type: application/json" -d '{"
 */
$app->post('/book', function (Request $request, Response $response) use ($app) {
 $params = (object) $request->getParams();
 /**
 * Pega o Entity Manager do nosso Container
 */
 $entityManager = $this->get('em');
 /**
 * Instância da nossa Entidade preenchida com nossos parametros do post
 */
 $book = (new Book())->setName($params->name)
 ->setAuthor($params->author);
 
 /**
 * Persiste a entidade no banco de dados
 */
 $entityManager->persist($book);
 $entityManager->flush();
 $logger = $this->get('logger');
 $logger->info('Book Created!', $book->getValues());
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 16/18
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 $return = $response->withJson($book,201)
 ->withHeader('Content-type', 'application/json');
 return $return;
});
/**
 * Atualiza os dados de um livro
 * @request curl -X PUT http://localhost:8000/book/14 -H "Content-type: application/json" -d '
 */
$app->put('/book/{id}', function (Request $request, Response $response) use ($app) {
 /**
 * Pega o ID do livro informado na URL
 */
 $route = $request->getAttribute('route');
 $id = $route->getArgument('id');
 /**
 * Encontra o Livro no Banco
 */ 
 $entityManager = $this->get('em');
 $booksRepository = $entityManager->getRepository('App\Models\Entity\Book');
 $book = $booksRepository->find($id); 
 /**
 * Monolog Logger
 */
 $logger = $this->get('logger');
 /**
 * Verifica se existe um livro com a ID informada
 */
 if (!$book) {
 $logger->warning("Book {$id} Not Found - Impossible to Update"); 
 throw new \Exception("Book not Found", 404);
 } 
 /**
 * Atualiza e Persiste o Livro com os parâmetros recebidos no request
 */
 $book->setName($request->getParam('name'))
 ->setAuthor($request->getParam('author'));
 /**
 * Persiste a entidade no banco de dados
 */
$entityManager >persist($book);
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 17/18
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 $entityManager->persist($book);
 $entityManager->flush(); 
 $logger->info("Book {$id} updated!", $book->getValues());
 $return = $response->withJson($book, 200)
 ->withHeader('Content-type', 'application/json');
 return $return;
});
/**
 * Deleta o livro informado pelo ID
 * @request curl -X DELETE http://localhost:8000/book/3
 */
$app->delete('/book/{id}', function (Request $request, Response $response) use ($app) {
 /**
 * Pega o ID do livro informado na URL
 */
 $route = $request->getAttribute('route');
 $id = $route->getArgument('id');
 /**
 * Monolog Logger
 */
 $logger = $this->get('logger');
 /**
 * Encontra o Livro no Banco
 */ 
 $entityManager = $this->get('em');
 $booksRepository = $entityManager->getRepository('App\Models\Entity\Book');
 $book = $booksRepository->find($id); 
 /**
 * Verifica se existe um livro com a ID informada
 */
 if (!$book) {
 $logger->info("Book {$id} not Found");
 throw new \Exception("Book not Found", 404);
 } 
 /**
 * Remove a entidade
 */
 $entityManager->remove($book);
 $entityManager->flush(); 
 $logger->info("Book {$id} deleted", $book->getValues());
17/06/2020 Slim Framework — Criando Microservices 07— Implementando Segurança Básica com HTTP Auth, JWT, e Proxy Scheme
https://medium.com/@fidelissauro/slim-framework-criando-microservices-07-implementando-segurança-básica-com-http-auth-e-proxy-ed6dd6… 18/18
Nosso código até aqui: https://github.com/msfidelis/slim-microservices/tree/v7
PHP Slim Microservices
About Help Legal
Get the Medium app
194
195
196
197
198
199
 $return = $response->withJson(['msg' => "Deletando o livro {$id}"], 204)
 ->withHeader('Content-type', 'application/json');
 return $return;
});
https://github.com/msfidelis/slim-microservices/tree/v7
https://medium.com/tag/php
https://medium.com/tag/slim
https://medium.com/tag/microservices
https://medium.com/?source=post_page-----ed6dd6d517f4----------------------
https://medium.com/about?autoplay=1&source=post_page-----ed6dd6d517f4----------------------
https://help.medium.com/?source=post_page-----ed6dd6d517f4----------------------
https://medium.com/policy/9db0094a1e0f?source=post_page-----ed6dd6d517f4----------------------
https://itunes.apple.com/app/medium-everyones-stories/id828256236?pt=698524&mt=8&ct=post_page&source=post_page-----ed6dd6d517f4----------------------
https://play.google.com/store/apps/details?id=com.medium.reader&source=post_page-----ed6dd6d517f4----------------------