diff --git a/config.toml b/config.toml
index 4c8bf391..49a4ea7a 100644
--- a/config.toml
+++ b/config.toml
@@ -322,10 +322,19 @@ params = ["categories", "tags"]
contentDir = "content/zh"
languageName = "中文"
weight = 2
+ [languages.ptbr]
+ contentDir = "content/pt-br"
+ languageName = "Português do Brasil"
+ weight = 3
### LANGUAGE-SPECIFIC MENUS ###
+
+
+
+
+
# Chinese menus
[[languages.zh.menu.docs]]
@@ -486,3 +495,168 @@ params = ["categories", "tags"]
identifier = "github"
post = "external"
url = "https://github.com/networknt/light-4j"
+
+
+# Brazilian portuguese menus
+
+[[languages.ptbr.menu.docs]]
+ name = "Light"
+ weight = 1
+ identifier = "about"
+ url = "/ptbr/about/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Documentação"
+ weight = 5
+ identifier = "getting-started"
+ url = "/ptbr/getting-started/"
+
+
+# Core languages.ptbr.menus
+
+[[languages.ptbr.menu.docs]]
+ name = "Arquitetura"
+ weight = 10
+ identifier = "architecture"
+ post = "expanded"
+ url = "/ptbr/architecture/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Design"
+ weight = 15
+ identifier = "design"
+ post = "expanded"
+ url = "/ptbr/design/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Referências"
+ weight = 20
+ identifier = "concern"
+ url = "/ptbr/concern/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Estilo"
+ weight = 25
+ identifier = "style"
+ url = "/ptbr/style/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Serviço"
+ weight = 30
+ identifier = "service"
+ url = "/ptbr/service/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Ferramentas"
+ weight = 35
+ post = "expanded"
+ identifier = "tool"
+ url = "/ptbr/tool/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Biblioteca"
+ weight = 36
+ post = "expanded"
+ identifier = "library"
+ url = "/ptbr/library/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Consumidor"
+ weight = 38
+ identifier = "consumer"
+ url = "/ptbr/consumer/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Desenvolvimento"
+ weight = 39
+ identifier = "development"
+ url = "/ptbr/development/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Implantação"
+ weight = 40
+ identifier = "deployment"
+ url = "/ptbr/deployment/"
+
+
+# LOW LEVEL ITEMS
+
+[[languages.ptbr.menu.docs]]
+ name = "Exemplo"
+ weight = 40
+ identifier = "example"
+ url = "/ptbr/example/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Tutorial"
+ weight = 45
+ identifier = "tutorial"
+ url = "/ptbr/tutorial/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Benchmark"
+ weight = 50
+ identifier = "benchmark"
+ url = "/ptbr/benchmark/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Solução de problemas"
+ weight = 60
+ identifier = "troubleshooting"
+ url = "/ptbr/troubleshooting/"
+
+[[languages.ptbr.menu.docs]]
+ name = "F.A.Q."
+ weight = 70
+ identifier = "faq"
+ url = "/ptbr/faq/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Milestone"
+ weight = 90
+ identifier = "milestone"
+ url = "/ptbr/milestone/"
+
+[[languages.ptbr.menu.docs]]
+ name = "Contribua"
+ weight = 100
+ post = "break"
+ identifier = "contribute"
+ url = "/ptbr/contribute/"
+
+[[languages.ptbr.menu.global]]
+ name = "Novidades"
+ weight = 1
+ identifier = "news"
+ url = "/ptbr/news/"
+
+[[languages.ptbr.menu.global]]
+ name = "Documentação"
+ weight = 5
+ identifier = "docs"
+ url = "/ptbr/documentation/"
+
+
+# Anything with a weight > 100 gets an external icon
+[[languages.ptbr.menu.global]]
+ name = "Comunidade"
+ weight = 150
+ icon = true
+ identifier = "community"
+ post = "external"
+ url = "https://discourse.gohugo.io/"
+
+[[languages.ptbr.menu.global]]
+ name = "Reddit"
+ weight = 160
+ icon = true
+ identifier = "reddit"
+ post = "external"
+ url = "https://www.reddit.com/r/lightapi/"
+
+[[languages.ptbr.menu.global]]
+ name = "GitHub"
+ weight = 200
+ identifier = "github"
+ post = "external"
+ url = "https://github.com/networknt/light-4j"
diff --git a/content/en/tutorial/portal/local-router/_index.md b/content/en/tutorial/portal/local-router/_index.md
index 67071b56..16fb9e57 100644
--- a/content/en/tutorial/portal/local-router/_index.md
+++ b/content/en/tutorial/portal/local-router/_index.md
@@ -23,4 +23,3 @@ This tutorial helps users to learn how to set up production like environment loc
* [Deploy View](/tutorial/portal/local-router/deploy-view/)
* [Build Portal](/tutorial/bot/light-portal-local/)
* [Start Portal](/tutorial/portal/local-router/start-portal/)
-
diff --git a/content/pt-br/_index.md b/content/pt-br/_index.md
new file mode 100644
index 00000000..328ce8f7
--- /dev/null
+++ b/content/pt-br/_index.md
@@ -0,0 +1,62 @@
+---
+title: "A High Throughput, Low Latency and Small Memory Footprint API Platform"
+date: 2017-03-02T12:00:00-05:00
+features:
+ - heading: Blistering Speed and Small Memory Footprint
+ image_path: /images/icon-fast.svg
+ tagline: Save 10x to 100x on production provision costs
+ copy: You need hundreds of instances of Spring Boot with Tomcat embedded to match one instance of light-4j in "Hello World" for the same throughput and latency.
+
+ - heading: Embedded Gateway to Address all Cross-cutting Concerns
+ image_path: /images/icon-content-management.svg
+ tagline: Maximize developers productivity by focusing on business logic only
+ copy: Plugin architecture that allows middleware handlers to be injected into the request/response chain to handler security, metrics, audit etc.
+
+ - heading: Design and Test Driven Development
+ image_path: /images/icon-shortcodes.svg
+ tagline: OpenAPI specification, Unit, Integration, End-to-End and Client Tests
+ copy: Generate code from specification and encourage unit tests, integration tests, end-to-end test as well as client tests to ensure quality and interoperability.
+
+ - heading: Built-in DevOps Tool Chain for CI/CD
+ image_path: /images/icon-built-in-templates.svg
+ tagline: Light-bot pipeline, Ansible playbook, Docker and Kubernetes
+ copy: The entire tool chain (pipeline) and infrastructure (logging, metrics, messaging, security etc.) are integrated together for microservices and services are dockerized and orchestrated by Kubernetes.
+
+ - heading: Multi-Style Support for Different Products
+ image_path: /images/icon-multilingual2.svg
+ tagline: Both synchronous request/response and asynchronous event driven frameworks
+ copy: Support Restful(light-rest-4j), Graphql(light-graphql-4j), Hybrid(light-hybrid-4j) and Eventuate Consistency(light-eventuate-4j). Also Saga(light-saga-4j) for transaction orchestration between services.
+
+ - heading: OAuth2, Portal and Services to Form an Ecosystem
+ image_path: /images/icon-custom-outputs.svg
+ tagline: Provide a platform for on-premise solutions as well as hosted solutions
+ copy: light-oauth2 for security and light-portal is for service runtime monitoring and management and API marketplace. Kafka for messaging, ELK for logging, InfluxDB and Grafana for metrics and ArangoDB for DB.
+sections:
+ - heading: "Cross-Cutting Concerns"
+ cta: Check out light-4j middleware handlers.
+ link: /concern/
+ color_classes: bg-primary-color-light black
+ image: /images/home-page-templating-example.png
+ copy: "Light-4j and related frameworks provide dozens of middleware handlers that can be injected into the request/response chain to give your service an embedded gateway."
+ - heading: "Interaction Styles"
+ cta: Use the right framework for the right product.
+ link: /architecture/category/
+ color_classes: bg-primary-color-light black
+ image: /images/home-page-templating-example.png
+ copy: "Restful for public API, Graphql for mobile and Sing Page Application, Hybrid for serverless and take advantage of both Monolithic and Microservices architecture. Eventuate for event driven."
+ - heading: "Infrastructure Services"
+ cta: OAuth2, Portal and other infrastructure services.
+ link: /service/
+ color_classes: bg-primary-color-light black
+ image: /images/home-page-templating-example.png
+ copy: "OAuth2 provider is responsible for centralize policy management and services are responsible for policy enforcement. Portal is API management and marketplace. Others are third party services."
+ - heading: "Tool Chains"
+ cta: Tool chain for code generation, devops and CI/CD.
+ link: /tool/
+ color_classes: bg-primary-color-light black
+ image: /images/home-page-templating-example.png
+ copy: "Light-codegen is used for scaffolding project from OpenAPI spec, GraphQL IDL or Hybrid Schema. Light-bot Pipeline for building, packaging, releasing and dockerizing. Kubernetes is for service orchestration."
+
+---
+
+Light means light-weight, lighting fast and shed light on how to program with modern Java SE.
diff --git a/content/pt-br/consumer/_index.md b/content/pt-br/consumer/_index.md
new file mode 100644
index 00000000..c7bd5187
--- /dev/null
+++ b/content/pt-br/consumer/_index.md
@@ -0,0 +1,71 @@
+---
+title: "Consumidor de serviço"
+date: 2019-04-27T13:37:28-03:00
+description: ""
+categories: []
+keywords: []
+menu:
+ docs:
+ parent: "consumer"
+ weight: 1
+weight: 1
+aliases: []
+toc: false
+draft: true
+---
+
+Maioria dessas seções neste site são como construir, implantar e gerenciar serviços.
+Esta seção discutirá arquitetura de microserviços e melhores práticas da perspectiva do consumidor.
+
+Ao contrário de monolitos web services JavaEE com somente um cliente e um servidor, há muitos microserviços
+envolvidos em uma requisição externa e é muito importante a latência geral na eficiência na comunicação cliente e servidor.
+
+A definição de cliente vs servidor ou consumidor vs provedor é ofuscada como um serviço que pode ser o servidor para um outro serviço
+e ao mesmo tempo isto pode ser um cliente para outro serviço.
+
+O menu abaixo contém arquitetura, design e melhores práticas:
+
+- [Módulo cliente](/ptbr/consumer/client-module/)
+ * [Arquivos jar](/ptbr/consumer/jar-files/)
+ * [Conexão TLS](/ptbr/consumer/tls-connection/)
+ * [HTTP 2.0](/ptbr/consumer/http2/)
+ * [Segurança](/architecture/security/)
+ + [Token de entidade](/ptbr/consumer/subject-token/)
+ + [Token de acesso](/ptbr/consumer/access-token/)
+ + [Tipo de concessão personalizado](/ptbr/consumer/customized-grant/)
+ + [Obter token no Startup](/ptbr/consumer/token-startup/)
+ + [Token de longa duração](/ptbr/consumer/long-lived-token/)
+ + [Distribuição de chave](/architecture/key-distribution/)
+ + [Criptografia secreta](/ptbr/consumer/secret-encryption/)
+ + [SPA Stateful](/ptbr/consumer/spa-session-jwt/)
+ + [SPA Stateless](/ptbr/consumer/spa-cookie-jwt/)
+ + [SPA prevenção de CSRF](/ptbr/consumer/spa-csrf/)
+ + [SPA prevença de XSS](/ptbr/consumer/spa-xss/)
+ + [SPA BFF](/ptbr/consumer/spa-bff/)
+ * [Rastreabilidade](/ptbr/consumer/traceability/)
+ + [Id da Rastreabilidade](/ptbr/consumer/traceability-id/)
+ + [Id de correlação](/ptbr/consumer/correlation-id/)
+ * [Circuit Breaker](/ptbr/consumer/circuit-breaker/)
+ * [CompletableFuture](/ptbr/consumer/completable-future/)
+- [light-consumer-4j](/ptbr/consumer/light-consumer-4j/)
+- [Service Discovery](/ptbr/consumer/service-discovery/)
+ * [Registry](/ptbr/consumer/registry/)
+ + [Standalone](/ptbr/consumer/standalone-registry/)
+ + [Docker](/ptbr/consumer/docker-registry/)
+ + [Kubernetes](/ptbr/consumer/kubernetes-registry/)
+ * [Discovery](/ptbr/consumer/discovery/)
+ + [Consul](/ptbr/consumer/consul-discovery/)
+ + [Zookeeper](/ptbr/consumer/zookeeper-discovery/)
+ * [SPA e móvel](/ptbr/consumer/spa-mobile/)
+- [Load Balance](/ptbr/consumer/load-balance/)
+ * [Round Robin](/ptbr/consumer/round-robin/)
+ * [Local First](/ptbr/consumer/local-first/)
+ * [Consistent Hash](/ptbr/consumer/consistent-hash/)
+- [Light Router](/ptbr/consumer/light-router/)
+ * [Casos de uso](/ptbr/consumer/router-use-case/)
+ * [Localização e propriedade](/service/router/location-ownership/)
+- [Single Page Application](/ptbr/consumer/spa/)
+ * [React](/ptbr/consumer/react/)
+ * [React-schema-form](/ptbr/consumer/react-schema-form/)
+ * [Vue](/ptbr/consumer/vue/)
+ * [Angular](/ptbr/consumer/angular/)
diff --git a/content/pt-br/consumer/access-token.md b/content/pt-br/consumer/access-token.md
new file mode 100644
index 00000000..5c9cfae9
--- /dev/null
+++ b/content/pt-br/consumer/access-token.md
@@ -0,0 +1,26 @@
+---
+title: "Access Token"
+date: 2018-03-01T21:37:48-05:00
+description: ""
+categories: []
+keywords: []
+weight: 60
+aliases: []
+toc: false
+draft: false
+---
+
+Access token é utilizado para invocação de serviço a serviço ou aplicação standalone que invoca um serviço.
+Geralmente, este token é recebido de um provedor OAuth2 2.0 através do fluxo de permissionamento de
+credenciais do cliente.
+O token não tem qualquer informação sobre o usuário mas somente tem client_id para indicar quem é a
+aplicação que invocou.
+
+Access token é muito importante para escopos de serviço que invoca como [Token de entidade][],
+na cadeia de invocação não terá escopos para todos os serviços.
+
+Se access token é somente o token disponível, isso é passado em Authorization header caso contrário,
+isso é passado em um X-Scope-Token na requisição.
+
+
+[Token de entidade]: /ptbr/consumer/subject-token/
diff --git a/content/pt-br/consumer/angular.md b/content/pt-br/consumer/angular.md
new file mode 100644
index 00000000..c80c0e21
--- /dev/null
+++ b/content/pt-br/consumer/angular.md
@@ -0,0 +1,17 @@
+---
+title: "Angular"
+date: 2018-12-24T18:27:22-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+Junto com React, Angular é outro framework javascript para consturir single page applications, há mutios usuários que tem construído angular SPA e acessa serviços/APIs construído no topo da plataforma light. Quando há múltiplos serviços no backend e esses serviços são implantados na nuvem,
+light-router será utilizado como um único ponto de acesso para o SPA. O light-router é também responsável por servir ao SPA para eliminar dependência de C.O.R.S. middleware handler na instância light-router para ganhar melhor performance.
+
+o seguinte é a lista de projetos open source que utilizam Angular como UI.
+
diff --git a/content/pt-br/consumer/circuit-breaker.md b/content/pt-br/consumer/circuit-breaker.md
new file mode 100644
index 00000000..9b173d2f
--- /dev/null
+++ b/content/pt-br/consumer/circuit-breaker.md
@@ -0,0 +1,28 @@
+---
+title: "Circuit Breaker"
+date: 2019-04-25T14:58:19-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+Circuit breaker pode ser utilizado através do método Http2Client::getRequestService, isto utiliza uma requisição envolvida por um produtor de java.util.concurrent.CompletableFuture, ou seja, toda vez que executa CircuitBreaker::call, cria uma nova requisição e executa a requisição.
+
+Há uma configuração específica no client.yml, exemplo:
+
+```yml
+request:
+ errorThreshold: 5
+ timeout: 3000
+ resetTimeout: 600000
+```
+
+* errorThreshold: quantidade de errors de timeout antes de mudar o estado de aberto (valor padrão: 5).
+* timeout: quantidade de tempo em milisegundos para esperar pela resposta de uma requisição (valor padrão: 5000)
+* resetTimeout: quantidade de tempo em milisegundos para manter estado aberto antes de mudar para meio aberto (valor padrão: 60000).
+
+se não é provido um valor para qualquer parâmetro, é adotado valor padrão.
\ No newline at end of file
diff --git a/content/pt-br/consumer/client-module.md b/content/pt-br/consumer/client-module.md
new file mode 100644
index 00000000..6a11af32
--- /dev/null
+++ b/content/pt-br/consumer/client-module.md
@@ -0,0 +1,36 @@
+---
+title: "Módulo Cliente"
+date: 2018-03-01T21:33:09-05:00
+description: ""
+categories: []
+keywords: []
+weight: 10
+aliases: []
+toc: false
+draft: false
+---
+
+O [Módulo Cliente][] em light-4j é um componente muito importante na plataforma light para
+interações entre cliente para serviço ou serviço para serviço em requisições/respostas sincronas
+sobre HTTPS e HTTP2. Microserviços são esperado ter alta performance a baixa latência para
+que múltiplos serviços podem ser encadeados juntos para cumprir uma requisição externa.
+Isso é porque o módulo cliente é desenhado para conexão direta entre consumidor e provedor com o
+HTTP 2.0 sobre conexão TLS cacheado no lado do consumidor para maioria de aplicações de alto rendimento.
+Para consumidores de baixo rendimento, a conexão pode ser fechada depois da requisição e reaberta quando
+a próxima requisição chega.
+
+Há muitas funcionalidades no módulo cliente e esses deveriam ser utilizado em certos cenários.
+A seguinte seçao mostra como usar o módulo cliente para casos de uso comum e os detalhes é documentado
+aqui também.
+
+- [Conexão TLS](/ptbr/consumer/tls-connection/)
+- [HTTP 2.0](/ptbr/consumer/http2/)
+- [OAuth 2.0 JWT Token](/ptbr/consumer/oauth2-jwt/)
+ * [Token de entidade](/ptbr/consumer/subject-token/)
+ * [Token de acesso](/ptbr/consumer/access-token/)
+ * [Tipo de concessão personalizado](/ptbr/consumer/customized-grant/)
+ * [Obter Token no Startup](/ptbr/consumer/token-startup/)
+ * [Token de longa duração](/ptbr/consumer/long-lived-token/)
+
+
+[Módulo cliente]: /concern/client/
\ No newline at end of file
diff --git a/content/pt-br/consumer/completable-future.md b/content/pt-br/consumer/completable-future.md
new file mode 100644
index 00000000..2f64928f
--- /dev/null
+++ b/content/pt-br/consumer/completable-future.md
@@ -0,0 +1,11 @@
+---
+title: "Completable Future"
+date: 2019-04-25T14:58:32-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/consistent-hash.md b/content/pt-br/consumer/consistent-hash.md
new file mode 100644
index 00000000..0edbd4dd
--- /dev/null
+++ b/content/pt-br/consumer/consistent-hash.md
@@ -0,0 +1,11 @@
+---
+title: "Consistent Hash"
+date: 2018-03-01T21:41:25-05:00
+description: ""
+categories: []
+keywords: []
+weight: 240
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/consul-discovery.md b/content/pt-br/consumer/consul-discovery.md
new file mode 100644
index 00000000..7cf0227f
--- /dev/null
+++ b/content/pt-br/consumer/consul-discovery.md
@@ -0,0 +1,17 @@
+---
+title: "Consul Discovery"
+date: 2018-03-01T21:40:31-05:00
+description: ""
+categories: []
+keywords: []
+weight: 190
+aliases: []
+toc: false
+draft: false
+---
+
+
+Serviço de descoberta do Consul é habilitada pelo [consul][] módulo em light-4j e isso é a melhor solução geral para o registro de serviço e descoberta na plataforma light. Você pode também escolher zookeeper mas isso não é recomendável.
+
+[consul]: /concern/consul/
+[zookeeper]: /ptbr/consumer/zookeeper-discovery/
diff --git a/content/pt-br/consumer/correlation-id.md b/content/pt-br/consumer/correlation-id.md
new file mode 100644
index 00000000..14017778
--- /dev/null
+++ b/content/pt-br/consumer/correlation-id.md
@@ -0,0 +1,11 @@
+---
+title: "Correlation Id"
+date: 2018-03-01T21:39:20-05:00
+description: ""
+categories: []
+keywords: []
+weight: 120
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/customized-grant.md b/content/pt-br/consumer/customized-grant.md
new file mode 100644
index 00000000..2a9df49c
--- /dev/null
+++ b/content/pt-br/consumer/customized-grant.md
@@ -0,0 +1,11 @@
+---
+title: "Customized Grant"
+date: 2018-03-01T21:38:00-05:00
+description: ""
+categories: []
+keywords: []
+weight: 70
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/discovery.md b/content/pt-br/consumer/discovery.md
new file mode 100644
index 00000000..435208fe
--- /dev/null
+++ b/content/pt-br/consumer/discovery.md
@@ -0,0 +1,37 @@
+---
+title: "Descoberta de serviços"
+date: 2018-03-01T21:40:21-05:00
+description: ""
+categories: []
+keywords: []
+weight: 180
+aliases: []
+toc: false
+draft: false
+---
+Quando implantar microserviços para um cluster kubernete na nuvem, há nenhum IP estático e número de porta para esses
+serviços. Para invocar esses serviços, ou você usa proxies provido por seu fornecedor de cluster kubernetes ou manipula
+isso com serviço de registro da plataforma light e descoberta na rede do host.
+
+Fizemos um teste de desempenho com um de nossos clientes no cluster Openhift e encontramos os seguintes números interessantes com um dos serviços criados sobre o light-rest-4j.
+
+### Uso de proxies Openshift
+
+* Taxa de transferência: 2450
+* Latência: 68ms
+
+### Uso de descoberta de serviço Consul
+
+* Taxa de transferência: 20000
+* Latência: 6ms
+
+Como você pode ver, quando os proxies são usados no Openshift, todo o cluster só pode ter um total de aproximadamente 2.500 solicitações por segundo. Imagine que você tenha centenas de serviços compartilhando o mesmo throughput, então cada serviço terá apenas várias solicitações por segundo.
+
+Acima está a razão pela qual temos que fornecer nosso próprio registro de serviço e descoberta para que nossos serviços possam se comunicar entre si sem passar por qualquer proxy. Isso significa que não precisamos de nenhum salto extra na rede. Como temos conexão direta com o HTTP 2.0 que suporta multiplexação, podemos cachear a conexão por alguns minutos ou várias solicitações para acelerar ainda mais a interação dos serviços.
+
+### Resumo
+
+Há vários produtos de código aberto que suportam registro de serviço e descoberta no mercado. Nós implementamos o módulo em light-4j para suportar tanto [Consul] [] quanto [Zookeeper] [].
+
+[Consul]: /ptbr/consumer/consul-discovery/
+[Zookeeper]: /ptbr/consumer/zookeeper-discovery/
diff --git a/content/pt-br/consumer/docker-registry.md b/content/pt-br/consumer/docker-registry.md
new file mode 100644
index 00000000..42b3434c
--- /dev/null
+++ b/content/pt-br/consumer/docker-registry.md
@@ -0,0 +1,11 @@
+---
+title: "Docker Registry"
+date: 2018-03-01T21:39:58-05:00
+description: ""
+categories: []
+keywords: []
+weight: 160
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/http2.md b/content/pt-br/consumer/http2.md
new file mode 100644
index 00000000..0dd34459
--- /dev/null
+++ b/content/pt-br/consumer/http2.md
@@ -0,0 +1,69 @@
+---
+title: "HTTP 2.0"
+date: 2018-03-01T21:37:12-05:00
+description: ""
+categories: []
+keywords: []
+weight: 30
+aliases: []
+toc: false
+draft: false
+---
+
+Por padrão, os serviços construídos em cima da plataforma light têm o HTTP 2.0 ativado automaticamente
+no light-codegen. O servidor também suporta conexão HTTP 1.1 se o cliente não puder
+negociar o HTTP 2.0 com o servidor.
+
+Existem muitos benefícios com o HTTP 2.0, mas o JDK 8 ou menor não suportam nativamente. Apesar
+que existem algumas alternativas, nenhuma delas é uma solução prática. Dada a situação, temos
+construído módulo cliente baseado no núcleo Undertow para suporte a HTTP 2.0.
+
+Segue alguns links a respeito de HTTP 2.0 e HTTP 1.1
+
+https://www.pacwebhosting.co.uk/insight/News/NewsItem/View/31/http11-vs-http2-whats-the-difference
+
+https://imagekit.io/demo/http2-vs-http1
+
+https://www.upwork.com/hiring/development/the-http2-protocol-its-pros-cons-and-how-to-start-using-it/
+
+### Configuração do servidor
+
+Para habilitar HTTP 2.0 no lado do servidor, você precisa garantir que enableHttp2 possui o valor true no
+arquivo de configuração server.yml.
+
+Por favor referencie ao [server module] e configuração do server.yml para mais informações.
+
+### Módulo cliente
+
+Ao usar o módulo do cliente light-4j para fazer uma solicitação HTTP para o servidor, o HTTP 2.0 não está ativado
+por padrão. Você precisa especificar explicitamente que deseja estabelecer uma conexão HTTP 2.0.
+
+Aqui está o exemplo de código para criar essa conexão:
+```java
+ if(connection == null || !connection.isOpen()) {
+ try {
+ connection = client.connect(new URI(apibHost), Http2Client.WORKER, Http2Client.SSL, Http2Client.POOL, OptionMap.create(UndertowOptions.ENABLE_HTTP2, true)).get();
+ } catch (Exception e) {
+ logger.error("Exeption:", e);
+ throw new ClientException(e);
+ }
+ }
+```
+
+A opção abaixo criará uma conexão HTTP 2.0
+```java
+
+OptionMap.create(UndertowOptions.ENABLE_HTTP2, true)
+
+```
+
+Se você tem certeza de que o serviço é construído em light-4j e o HTTP 2.0 não está desabilitado. Então você deveria
+usar o HTTP 2.0 do lado do consumidor para aproveitar a velocidade rápida e multiplexação de conexão única.
+
+### Outro HTTP cliente java
+
+A maioria dos clientes HTTP Java não suporta HTTP 2.0 ou você tem que encontrar uma solução alternativa para fazer isso com
+bootclasspath jar file por versão do JDK em Java 8. Se você estiver usando o Java 9, então ele tem
+suporte para HTTP 2.0; no entanto, nunca foi testado com o framework básico.
+
+[server module]: /concern/server/
diff --git a/content/pt-br/consumer/jar-files.md b/content/pt-br/consumer/jar-files.md
new file mode 100644
index 00000000..30fee104
--- /dev/null
+++ b/content/pt-br/consumer/jar-files.md
@@ -0,0 +1,68 @@
+---
+title: "Arquivos Jar"
+date: 2018-05-07T12:30:59-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+Ao usar o módulo cliente a partir de qualquer aplicativo Java construído sobre o Java 8, mas não na plataforma light, vários módulos precisam ser incluídos juntos para executar várias funções, incluindo solicitação HTTP/2, descoberta de serviço, balanceamento de carga e suporte a cluster. Esses arquivos jar são pequenos e contêm apenas de 2 a 5 classes. A lista a seguir inclui todos os arquivos jar relacionados do Maven Central ao usar o módulo do cliente.
+
+
+Para todos os módulos listados abaixo, há 3 arquivos de configurações que precisa ser externalizado para funcionar, são:
+
+1. client.yml - Define configuração do cliente e comunicação OAuth 2.0. É apenas utilizado pelo módulo cliente.
+2. service.yml - balance, cluster, registry, consul e configuração de decifradora são definidas nesse arquivo.
+3. secret.yml - OAuth 2.0 client secret e senha de certificado etc. são definidos neste arquivo para facilitar o gerenciamento de segredos. Todos os secredos podem ser encriptados em texto não claros para ser visto no arquivo de
+configuração.
+
+* [client.jar][]
+
+É o arquivo jar principal que é responsável por criar uma conexão HTTP/2, enviar solicitações e invocar chamadas de retorno do cliente. Ele também lida com a renovação automática de tokens JWT do provedor do OAuth 2.0 e passa pelo correlationId e traceabilityId.
+
+* [config.jar][]
+
+Ele carrega arquivos de configuração dentro do módulo, aplicativo ou diretório externalizado.
+
+* [balance.jar][]
+
+É o módulo para lidar com o balanceamento de carga do lado do cliente. Suporta três estratégias integradas: Round Robin, Local First e Consistent Hashing.
+
+* [cluster.jar][]
+
+Suporte de cluster no lado do cliente, ele usa o módulo de balanceamento para pegar um candidato (IP e porta) de uma lista de instâncias descobertas.
+
+* [registry.jar][]
+
+Ele fornece lógica de descoberta de serviço geral junto com implementações concretas como Consul ou Zookeeper.
+
+* [consul.jar][]
+
+É um módulo cliente para a comunicação do agente Consul.
+
+* [service.jar][]
+
+Serviço de injeção de dependência que é responsável por conectar todos os outros módulos.
+
+* [decryptor.jar][]
+
+É um módulo opcional se você quiser criptografar dados confidenciais dos arquivos de configuração.
+
+* [common.jar][]
+
+É um módulo opcional e usado pelo decifrador pelo DecryptUtil.java.
+
+[client.jar]: /concern/client/
+[config.jar]: /concern/config/
+[balance.jar]: /concern/balance/
+[cluster.jar]: /concern/cluster/
+[registry.jar]: /concern/registry/
+[consul.jar]: /concern/consul/
+[service.jar]: /concern/service/
+[decryptor.jar]: /concern/decryptor/
+[common.jar]: /concern/common/
+
diff --git a/content/pt-br/consumer/kubernetes-registry.md b/content/pt-br/consumer/kubernetes-registry.md
new file mode 100644
index 00000000..4464c8cd
--- /dev/null
+++ b/content/pt-br/consumer/kubernetes-registry.md
@@ -0,0 +1,11 @@
+---
+title: "Kubernetes Registry"
+date: 2018-03-01T21:40:09-05:00
+description: ""
+categories: []
+keywords: []
+weight: 170
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/light-consumer-4j.md b/content/pt-br/consumer/light-consumer-4j.md
new file mode 100644
index 00000000..aac8d83c
--- /dev/null
+++ b/content/pt-br/consumer/light-consumer-4j.md
@@ -0,0 +1,157 @@
+---
+title: "Light Consumer 4j"
+date: 2018-12-05T13:04:18-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+# Light Consumer 4j
+
+Light Consumer 4h é um módulo que ajuda os consumidores (consumers) a integrar-se facilmente com as apis light-4j.
+Ele é construído em cima do Http2Client e java8, possui muitos recursos extras, como pool de conexão, etc.
+Ele suporta tanto a URL direta quanto a descoberta de serviço (Cônsul) para chamar as APIs.
+
+### Uso
+Adicione a dependência em seu projeto.
+
+```xml
+
+ com.networknt
+ light-consumer-4j
+ 1.5.26
+
+```
+
+Métodos disponíveis no ClientBuilder
+
+ Future send() // Envia requisição.
+
+ String getServiceUrl() // obtém o serviceUrl resolvido
+
+ disableHttp2() // Desabilita Http2, por padrão isso é habilitado.
+
+ setClientRequest(ClientRequest reg) // set requisição do cliente ao httpClientRequest.
+
+ setRequestBody(String requestBody) // set requestBody ao httpClientRequest.
+
+ setHeaderValue(HttpString headerName,..) // set headerName e headerValue ao httpClientRequest.
+
+ setApiHost(String apiUrl) // set apiUrl em httpClientRequest para chamar api com url direta.
+
+ setConnectionCacheTTLms(long tTLms) // set timeout de connexão de cache.
+
+ setRequestTimeout(TimeoutDef timeout) // set timeout da requisição.
+
+ setConnectionRequestTimeout(TimeoutDef t)// set timeout da conexão de requisição.
+
+ setAuthToken(String authToken) // Set o token de autenticação na requisição.
+
+ getAuthToken() // get token de autenticação
+
+ addCCToken() // adicione o token de acesso no header da requisição e também checa a expiração do token de acesso.
+
+ setServiceDef(ServiceDef serviceDef) // set protocolo, service id, ambiente e requestKey para chamada da API via consul.
+
+ setMaxReqCount(int maxReqCount) // habilita cache de conexão pelo número da requisição.
+
+
+ #### Aqui um exemplo de código para chamar a API.
+
+Chame a API com URL direta:
+
+Exemplo 1:
+```
+Future clientRequest = new HttpClientBuilder()
+
+ //set direct url
+ .setApiHost("https://localhost:8453")
+ .setClientRequest(new ClientRequest().setPath("/v1/customers/1").setMethod(Methods.GET))
+ .setLatch(new CountDownLatch(1))
+ .disableHttp2()
+ .addCCToken()
+ .setConnectionRequestTimeout(new TimeoutDef(100, TimeUnit.SECONDS))
+ .setRequestTimeout(new TimeoutDef(100, TimeUnit.SECONDS))
+ .setRequestBody("")
+ .setConnectionCacheTTLms(10000)
+ .setMaxReqCount(5)
+ .send();
+ClientResponse clientResponse = clientRequest.get();
+
+```
+Exemplo 2:
+
+```
+ public static final String CUSTOMERS_URL = "https://localhost:8453";
+ private static final String CUSTOMERS_PATH = "/v1/customers/{id}";
+
+ HttpClientBuilder clientBuilder = new HttpClientBuilder();
+
+ ClientRequest clientRequest = new ClientRequest().setMethod(Methods.GET)
+ .setPath(CUSTOMERS_PATH.replace("{id}", id));
+
+ clientBuilder.setClientRequest(clientRequest);
+ clientBuilder.setLatch(new CountDownLatch(1));
+ if (!Server.config.isEnableHttp2()) {
+ clientBuilder.disableHttp2();
+ }
+ clientBuilder.setApiHost(CUSTOMERS_URL);
+ clientBuilder.setConnectionCacheTTLms(20000);
+ clientBuilder.setMaxReqCount(5)
+ clientBuilder.setConnectionRequestTimeout(new TimeoutDef(10, TimeUnit.SECONDS));
+ Future clientBuilderRequest = clientBuilder.send();
+ ClientResponse clientResponse = clientBuilderRequest.get();
+```
+
+Chave a API via descoberta de serviço (Consul):
+
+Exemplo 1:
+
+```
+Future clientRequest = new HttpClientBuilder()
+
+ //set protocol,service id , environment and requestKey
+ .setServiceDef(new ServiceDef("https", "training.customers-1.00.00","training", null))
+ .setClientRequest(new ClientRequest().setPath("/v1/customers/1").setMethod(Methods.GET))
+ .setLatch(new CountDownLatch(1))
+ .disableHttp2()
+ .addCCToken()
+ .setConnectionRequestTimeout(new TimeoutDef(100, TimeUnit.SECONDS))
+ .setRequestTimeout(new TimeoutDef(100, TimeUnit.SECONDS))
+ .setRequestBody("")
+ .setConnectionCacheTTLms(10000)
+ .setMaxReqCount(5)
+ .send();
+ClientResponse clientResponse = clientRequest.get();
+
+```
+Exemplo 2:
+
+```
+ public static final String CUSTOMERS_SERVICE = "training.customers-1.00.00";
+ private static final String CUSTOMERS_PATH = "/v1/customers/{id}";
+
+ HttpClientBuilder clientBuilder = new HttpClientBuilder();
+
+ ClientRequest clientRequest = new ClientRequest().setMethod(Methods.GET)
+ .setPath(CUSTOMERS_PATH.replace("{id}", id));
+
+ clientBuilder.setClientRequest(clientRequest);
+ clientBuilder.setLatch(new CountDownLatch(1));
+ if (!Server.config.isEnableHttp2()) {
+ clientBuilder.disableHttp2();
+ }
+ clientBuilder.setServiceDef(new ServiceDef("https", CUSTOMERS_SERVICE, "training", null));
+ clientBuilder.setConnectionCacheTTLms(20000);
+ clientBuilder.setMaxReqCount(5);
+ clientBuilder.setConnectionRequestTimeout(new TimeoutDef(10, TimeUnit.SECONDS));
+ Future clientBuilderRequest = clientBuilder.send();
+ ClientResponse clientResponse = clientBuilderRequest.get();
+```
+
+
+
diff --git a/content/pt-br/consumer/light-router.md b/content/pt-br/consumer/light-router.md
new file mode 100644
index 00000000..4fcc5207
--- /dev/null
+++ b/content/pt-br/consumer/light-router.md
@@ -0,0 +1,11 @@
+---
+title: "Light Router"
+date: 2018-03-01T21:33:43-05:00
+description: ""
+categories: []
+keywords: []
+weight: 250
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/load-balance.md b/content/pt-br/consumer/load-balance.md
new file mode 100644
index 00000000..9fb9a592
--- /dev/null
+++ b/content/pt-br/consumer/load-balance.md
@@ -0,0 +1,11 @@
+---
+title: "Load Balance"
+date: 2018-03-01T21:33:34-05:00
+description: ""
+categories: []
+keywords: []
+weight: 210
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/local-first.md b/content/pt-br/consumer/local-first.md
new file mode 100644
index 00000000..ca8a7382
--- /dev/null
+++ b/content/pt-br/consumer/local-first.md
@@ -0,0 +1,11 @@
+---
+title: "Local First"
+date: 2018-03-01T21:41:09-05:00
+description: ""
+categories: []
+keywords: []
+weight: 230
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/long-lived-token.md b/content/pt-br/consumer/long-lived-token.md
new file mode 100644
index 00000000..212a202e
--- /dev/null
+++ b/content/pt-br/consumer/long-lived-token.md
@@ -0,0 +1,11 @@
+---
+title: "Long Lived Token"
+date: 2018-03-01T21:38:46-05:00
+description: ""
+categories: []
+keywords: []
+weight: 90
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/react-schema-form.md b/content/pt-br/consumer/react-schema-form.md
new file mode 100644
index 00000000..01408fb3
--- /dev/null
+++ b/content/pt-br/consumer/react-schema-form.md
@@ -0,0 +1,18 @@
+---
+title: "React Schema Form"
+date: 2018-12-24T19:00:30-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+[React schema form][] é baseado no esquema JSON para geração e validação de formulários. É uma porta do projeto de formulário de esquema angular usando material-ui para os componentes subjacentes.
+
+Para a aplicação de exemplo que utiliza react-schema-form, dê uma olhada ao [web-client][] de taiji-blockchain
+
+[React schema form]: https://github.com/networknt/react-schema-form
+[web-client]: https://github.com/taiji-chain/web-client/tree/master/server/view
diff --git a/content/pt-br/consumer/react.md b/content/pt-br/consumer/react.md
new file mode 100644
index 00000000..b10f97cc
--- /dev/null
+++ b/content/pt-br/consumer/react.md
@@ -0,0 +1,18 @@
+---
+title: "React"
+date: 2018-12-24T18:27:16-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+React é um dos mais populares bibliotecas Javascript para Single Page Applications, é muito bom na construção de componentes
+auto encapsulado.
+
+Internamente, estamos usando o React para quase todas as interfaces para vários serviços. Para acelerar o desenvolvimento, também desenvolvemos [react-schema-form] [], que pode gerar formulários e lógica para interagir com os serviços de back-end de forma unificada.
+
+[react-schema-form]: /ptbr/consumer/react-schema-form/
diff --git a/content/pt-br/consumer/registry.md b/content/pt-br/consumer/registry.md
new file mode 100644
index 00000000..785a6068
--- /dev/null
+++ b/content/pt-br/consumer/registry.md
@@ -0,0 +1,11 @@
+---
+title: "Registry"
+date: 2018-03-01T21:39:34-05:00
+description: ""
+categories: []
+keywords: []
+weight: 140
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/round-robin.md b/content/pt-br/consumer/round-robin.md
new file mode 100644
index 00000000..4b155860
--- /dev/null
+++ b/content/pt-br/consumer/round-robin.md
@@ -0,0 +1,11 @@
+---
+title: "Round Robin"
+date: 2018-03-01T21:41:01-05:00
+description: ""
+categories: []
+keywords: []
+weight: 220
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/router-location.md b/content/pt-br/consumer/router-location.md
new file mode 100644
index 00000000..3df92329
--- /dev/null
+++ b/content/pt-br/consumer/router-location.md
@@ -0,0 +1,11 @@
+---
+title: "Router Location"
+date: 2018-03-01T21:44:37-05:00
+description: ""
+categories: []
+keywords: []
+weight: 270
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/router-use-case.md b/content/pt-br/consumer/router-use-case.md
new file mode 100644
index 00000000..9a8ed257
--- /dev/null
+++ b/content/pt-br/consumer/router-use-case.md
@@ -0,0 +1,11 @@
+---
+title: "Router Use Case"
+date: 2018-03-01T21:44:28-05:00
+description: ""
+categories: []
+keywords: []
+weight: 260
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/secret-encryption.md b/content/pt-br/consumer/secret-encryption.md
new file mode 100644
index 00000000..e99f9d41
--- /dev/null
+++ b/content/pt-br/consumer/secret-encryption.md
@@ -0,0 +1,107 @@
+---
+title: "Codificador de segredos"
+date: 2018-03-07T21:17:38-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+A plataforma Light tem um [decodificador] [] que pode ser injetado no aplicativo para descriptografar códigos criptografados em arquivos de configuração. Existe um utilitário separado que é usado para criptografar o secret.yml ou outros arquivos de configuração que contêm informações confidenciais.
+
+Da perspectiva do consumidor, somente secret.yml será usado, a menos que o aplicativo cliente esteja tentando usar o
+recurso para proteger outros arquivos de configuração específicos do cliente.
+
+A seguir, um exemplo de secret.yml que pode ser usado junto com keystores client.yml e TLS.
+
+```yaml
+# This file contains all the secrets for the server and client in order to manage and
+# secure all of them in the same place. In Kubernetes, this file will be mapped to
+# Secrets and all other config files will be mapped to mapConfig
+
+---
+
+# Sever section
+
+# Key store password, the path of keystore is defined in server.yml
+serverKeystorePass: password
+
+# Key password, the key is in keystore
+serverKeyPass: password
+
+# Trust store password, the path of truststore is defined in server.yml
+serverTruststorePass: password
+
+
+# Client section
+
+# Key store password, the path of keystore is defined in server.yml
+clientKeystorePass: password
+
+# Key password, the key is in keystore
+clientKeyPass: password
+
+# Trust store password, the path of truststore is defined in server.yml
+clientTruststorePass: password
+
+# Authorization code client secret for OAuth2 server
+authorizationCodeClientSecret: f6h1FTI8Q3-7UScPZDzfXA
+
+# Client credentials client secret for OAuth2 server
+clientCredentialsClientSecret: f6h1FTI8Q3-7UScPZDzfXA
+
+# Key distribution client secret for OAuth2 server
+keyClientSecret: f6h1FTI8Q3-7UScPZDzfXA
+
+
+# Consul service registry and discovery
+
+# Consul Token for service registry and discovery
+consulToken: token1
+
+# EmailSender password default address is noreply@lightapi.net
+emailPassword: change-to-real-password
+
+```
+
+
+In most of the cases, the following fields are used by the client.
+
+```yaml
+
+# Client section
+
+# Key store password, the path of keystore is defined in server.yml
+clientKeystorePass: password
+
+# Key password, the key is in keystore
+clientKeyPass: password
+
+# Trust store password, the path of truststore is defined in server.yml
+clientTruststorePass: password
+
+# Authorization code client secret for OAuth2 server
+authorizationCodeClientSecret: f6h1FTI8Q3-7UScPZDzfXA
+
+# Client credentials client secret for OAuth2 server
+clientCredentialsClientSecret: f6h1FTI8Q3-7UScPZDzfXA
+
+# Key distribution client secret for OAuth2 server
+keyClientSecret: f6h1FTI8Q3-7UScPZDzfXA
+
+
+# Consul service registry and discovery
+
+# Consul Token for service registry and discovery
+consulToken: token1
+
+```
+
+Para aprender como usar o encriptador e decodificador, por favor, consulte o [tutorial] [].
+
+[decryptor]: /concern/decryptor/
+[tutorial]: /tutorial/security/encrypt-decrypt/
+
diff --git a/content/pt-br/consumer/service-discovery.md b/content/pt-br/consumer/service-discovery.md
new file mode 100644
index 00000000..83ffb217
--- /dev/null
+++ b/content/pt-br/consumer/service-discovery.md
@@ -0,0 +1,11 @@
+---
+title: "Service Discovery"
+date: 2018-03-01T21:33:21-05:00
+description: ""
+categories: []
+keywords: []
+weight: 130
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/spa-bff.md b/content/pt-br/consumer/spa-bff.md
new file mode 100644
index 00000000..4035bea1
--- /dev/null
+++ b/content/pt-br/consumer/spa-bff.md
@@ -0,0 +1,28 @@
+---
+title: "Single Page App Proxy"
+date: 2018-05-13T23:52:10-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+reviewed: true
+---
+
+Ao desenvolver o SPA React com uma estrutura do lado do cliente como o React, é aconselhável aproveitar o WebPack hot loader para obter maior produtividade. Isso requer que iniciemos um servidor Nodejs para servir o SPA ao navegador. Quando o SPA está chamando algumas das APIs, os servidores da API podem estar em outro host ou no mesmo host, mas com um número de porta diferente. Para garantir que o aplicativo Javascript precise especificar apenas o caminho relativo sem se preocupar com o host e a porta, precisamos configurar um proxy no arquivo package.json gerado.
+
+A seguir é um exemplo que nós estamos utilizando para desenvolvimento.
+
+```
+proxy: {
+ "/v1": {
+ target: "https://localhost:8443",
+ secure: false
+ }
+}
+```
+A configuração acima garantirá que todas as solicitações para o caminho /v1 sejam roteadas para o serviço https://localhost:8443. Como o servidor de destino está ouvindo HTTPS, precisamos definir o secure como false se um certificado autoassinado for usado no servidor.
+
+Para mais informação sobre configuração do proxy, por favor visitar o https://webpack.js.org/configuration/dev-server/
diff --git a/content/pt-br/consumer/spa-csrf.md b/content/pt-br/consumer/spa-csrf.md
new file mode 100644
index 00000000..35072db7
--- /dev/null
+++ b/content/pt-br/consumer/spa-csrf.md
@@ -0,0 +1,16 @@
+---
+title: "SPA CSRF Prevention"
+date: 2018-05-22T12:48:01-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+reviewed: true
+---
+
+Cross-Site Request Forgery (CSRF) é um tipo de ataque que ocorre quando um site, email, blog, mensagem instantânea ou programa mal-intencionado faz com que o navegador da Web de um usuário execute uma ação indesejada em um site confiável para o qual o usuário está atualmente autenticado. O impacto de um ataque CSRF bem-sucedido é limitado aos recursos expostos pelo aplicativo vulnerável. Por exemplo, esse ataque pode resultar em uma transferência de fundos, alteração de senha ou compra de um item no contexto do usuário. Com efeito, ataques de CSRF são usados por um invasor para fazer com que um sistema de destino execute uma função através do navegador de destino sem o conhecimento do usuário de destino, pelo menos até que a transação não autorizada seja confirmada.
+
+Os impactos das explorações bem-sucedidas do CSRF variam muito com base nos privilégios de cada vítima. Ao segmentar um usuário normal, um ataque CSRF bem-sucedido pode comprometer os dados do usuário final e suas funções associadas. Se o usuário final direcionado for uma conta de administrador, um ataque de CSRF pode comprometer todo o aplicativo da web. Os sites com maior probabilidade de serem atacados pelo CSRF são sites da comunidade (redes sociais, email) ou sites que possuem contas de alto valor em dólares associados a eles (bancos, corretoras de valores, serviços de pagamento de contas). Utilizando a engenharia social, um invasor pode incorporar códigos maliciosos de HTML ou JavaScript em um email ou site para solicitar uma "URL de tarefa" específica. A tarefa, em seguida, executa com ou sem o conhecimento do usuário, diretamente ou utilizando uma falha Cross-Site Scripting (ex: Samy MySpace Worm).
diff --git a/content/pt-br/consumer/spa-mobile.md b/content/pt-br/consumer/spa-mobile.md
new file mode 100644
index 00000000..99ca607b
--- /dev/null
+++ b/content/pt-br/consumer/spa-mobile.md
@@ -0,0 +1,39 @@
+---
+title: "SPA and Mobile Discovery"
+date: 2018-04-30T19:58:40-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+reviewed: true
+---
+
+Muitas vezes, quando discutimos a descoberta de serviços, aplicativos e serviços autônomos são mencionados como clientes. Raramente discutimos o SPA em execução no navegador e o aplicativo móvel em execução nos dispositivos, pois eles não são considerados para executar a descoberta de serviços.
+
+Na maioria dos casos, esses aplicativos se conectam da Internet a um balanceador de carga estática como o F5 e, em seguida, fazem o roteamento para várias instâncias BFF(Backend for Frontend) endereçadas estáticas. Portanto, mesmo que seja capaz de realizar descobertas a partir do SPA ou do aplicativo móvel, não há necessidade de fazê-lo, pois as instâncias do BFF são acessadas diretamente com endereços IP. Além disso, BFF é responsável por descobrir microsserviços em execução na nuvem com endereços IP dinâmicos e números de porta.
+
+A razão pela qual temos esse tipo de arquitetura é abordar as preocupações de segurança. Nossos serviços internos em execução na nuvem podem se conectar a bancos de dados, repositórios ou outros sistemas de back-end importantes. Eles não devem ser acessados diretamente da Internet. Eles residem na rede interna e só podem ser acessados através de BFFs que estão sendo executados no DMZ.
+
+Atualmente, o design típico seria um gateway de API que atua como um BFF, que lida com todas as solicitações externas e executa a filtragem de segurança. Ele funciona com serviços da Web monolíticos, mas não para microsserviços, pois o único gateway de API é o gargalo e o único ponto de falha.
+
+Ao adotar a arquitetura de microsserviços, precisamos de gateways de API distribuídos para que a carga de trabalho possa ser balanceada para diferentes instâncias especificamente projetadas para cada cliente. Esses gateways distribuídos conhecem as solicitações do cliente muito melhor e lidam com a segurança do cliente com o provedor do OAuth 2.0 para proteger a lógica complexa dos desenvolvedores clientes. Idealmente, esses gateways distribuídos devem ser construídos como microsserviços para garantir a escalabilidade a longo prazo.
+
+Na plataforma leve, três componentes podem atuar como um gateway distribuído, conhecido como BFF.
+
+
+### Servidor web existente
+
+Se suas APIs foram criadas sobre o servidor da Web existente e não podem migrar para a arquitetura de microsserviços durante a noite, você ainda poderá usar seu servidor da Web como um gateway para a descoberta de serviços. Isso requer que o servidor da Web seja construído no Java 8 e superior, de modo que o módulo do cliente light-4j possa ser utilizado para interagir com o provedor do OAuth 2.0 e com o Consul para descoberta de serviço. Se o servidor da Web não puder usar o módulo do cliente incorporado, o light-router poderá ser usado. Nesse design, o servidor da Web também atua como um agregador, de modo que uma solicitação do cliente possa invocar vários microsserviços no backend.
+
+### Agregador customizado
+
+Para novos aplicativos clientes, você pode construir um agregador no framework light-rest-4j ou light-graphql-4j como um microsserviço. Ele pode simplesmente simplificar a lógica de chamada do cliente e tornar os desenvolvedores do lado do cliente mais confortáveis. Essa camada também oculta os detalhes dos serviços de back-end para que nossas APIs de serviços de back-end não sejam expostas diretamente à Internet.
+
+### Roteador Light
+
+Com o HTTP 2.0 se popularizando, as necessidades de agregador não são tão importantes, já que um cliente pode acessar vários serviços simultaneamente sem penalidade de desempenho.
+
+Essa arquitetura também abre a porta para microsserviços verdadeiros, o que significa que a interface do usuário e a API são totalmente combinadas como um serviço que lida com uma função de negócios específica. Com estruturas do lado do cliente, como React ou React Native, a limitação é a sua imaginação.
diff --git a/content/pt-br/consumer/spa-session-jwt.md b/content/pt-br/consumer/spa-session-jwt.md
new file mode 100644
index 00000000..90dc70f5
--- /dev/null
+++ b/content/pt-br/consumer/spa-session-jwt.md
@@ -0,0 +1,35 @@
+---
+title: "SPA Session JWT"
+date: 2018-05-01T09:38:00-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+Ao criar SPA que consomem APIs protegidas por tokens JWT ou token simples da Web, muitos artigos sugerem colocar o token no armazenamento local no navegador para que o aplicativo Javascript possa usar o token para acessar as APIs diretamente. ** Por favor, não faça isso, pois não é seguro **.
+
+Como o artigo [pare de usar localstorage] indica, o armazenamento local no navegador não é segurança. Está sujeito a ataques de script entre sites, e as informações podem ser recuperadas por qualquer pessoa que tenha acesso ao navegador fisicamente.
+
+Se você precisar armazenar dados confidenciais, use sempre uma sessão do lado do servidor. Veja como fazer isso:
+
+* Quando um usuário faz login no seu site, crie um identificador de sessão para ele e armazene-o em um cookie assinado criptograficamente. Se você estiver usando uma estrutura da Web, procure "como criar uma sessão de usuário usando cookies" e siga aquele guia.
+
+* Certifique-se de que qualquer biblioteca de cookie usada pelo seu framework web esteja configurando o sinalizador httpOnly cookie. Esse sinalizador torna impossível para um navegador ler qualquer cookie, o que é necessário para usar com segurança as sessões do lado do servidor com cookies. Leia o [artigo do Jeff Atwood][] para mais informações. Ele é o cara.
+
+* Certifique-se de que sua biblioteca de cookies também defina o sinalizador de cookie SameSite = strict (para evitar ataques [CSRF] []), bem como o sinalizador secure = true (para garantir que os cookies só possam ser definidos em uma conexão criptografada).
+
+* Cada vez que um usuário faz uma solicitação ao seu site, use seu ID de sessão (extraído do cookie que ele envia para você) para recuperar os detalhes da conta de um banco de dados ou de um cache (dependendo do tamanho do site)
+
+* Depois que você tiver as informações da conta do usuário acessadas e verificadas, sinta-se à vontade para enviar os dados confidenciais associados.
+
+Esse padrão é simples, direto e, o mais importante: seguro. E sim, você pode definitivamente escalar um grande site usando este padrão ao usar [light-session-4j] [] que é uma sessão distribuída apoiada por uma grade de dados na memória.
+
+[pare de usar localstorage]: https://dev.to/rdegges/please-stop-using-local-storage-1i04
+[artigo do Jeff Atwood]: https://blog.codinghorror.com/protecting-your-cookies-httponly/
+[CSRF]: https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
+[light-session-4j]: /ptbr/sytle/light-session-4j/
+
diff --git a/content/pt-br/consumer/spa-xss.md b/content/pt-br/consumer/spa-xss.md
new file mode 100644
index 00000000..0e01b5b9
--- /dev/null
+++ b/content/pt-br/consumer/spa-xss.md
@@ -0,0 +1,11 @@
+---
+title: "Spa Xss"
+date: 2018-05-22T12:48:16-04:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/spa.md b/content/pt-br/consumer/spa.md
new file mode 100644
index 00000000..e4799cef
--- /dev/null
+++ b/content/pt-br/consumer/spa.md
@@ -0,0 +1,20 @@
+---
+title: "SPA - Single Page Application"
+date: 2018-12-24T18:27:09-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+Quando você constrói microsserviços, deve haver um consumidor final em algum lugar no topo da cadeia alimentar, e geralmente é um SPA que fornece uma interface para interagir com os usuários finais.
+
+Existem muitos frameworks e bibliotecas para construir SPAs, e nós recomendamos fortemente [React][]. Juntamente com o React, temos muitos usuários usando [Vue][] e [Angular][].
+
+[React]: /ptbr/consumer/react/
+[Vue]: /ptbr/consumer/vue/
+[Angular]: /ptbr/consumer/angular/
+
diff --git a/content/pt-br/consumer/standalone-registry.md b/content/pt-br/consumer/standalone-registry.md
new file mode 100644
index 00000000..8fc99264
--- /dev/null
+++ b/content/pt-br/consumer/standalone-registry.md
@@ -0,0 +1,11 @@
+---
+title: "Standalone Registry"
+date: 2018-03-01T21:39:51-05:00
+description: ""
+categories: []
+keywords: []
+weight: 150
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/subject-token.md b/content/pt-br/consumer/subject-token.md
new file mode 100644
index 00000000..87741bcc
--- /dev/null
+++ b/content/pt-br/consumer/subject-token.md
@@ -0,0 +1,37 @@
+---
+title: "Token de entidade"
+date: 2018-03-01T21:37:35-05:00
+description: ""
+categories: []
+keywords: []
+weight: 50
+aliases: []
+toc: false
+draft: false
+---
+
+Conforme descrito em [arquitetura de segurança] [], a plataforma light usa dois tokens para proteger o serviço
+para atender chamadas. Um token é o token original do usuário de login e tem original
+informações do chamador e possíveis informações adicionais para autorização de baixa granularidade. Este token
+é chamado Token de entidade.
+
+O token de entidade representa uma pessoa e tem user_id e informações adicionais do usuário em potencial.
+
+Há duas maneiras para obter esse token.
+
+* Fluxo de concessão de autorização para o provedor do OAuth 2.0
+
+* OpenID Connect
+
+Este token é passado no cabeçalho de solicitação "Authorization" na maioria dos casos e se o token
+contém informação de escopo para acessar a API/serviço, então nenhum Token de Acesso é necessário. este
+é o servidor web da situação como um cliente chamando APIs.
+
+This token is passed in request header "Authorization" in most of the cases and if the token
+contains scope info to access the immediate API/service, then no Access Token is needed. This
+is the situation webserver as a client calling APIs.
+
+
+[security architecture]: /architecture/security/
+[Access Token]: /ptbr/consumer/access-token/
+
diff --git a/content/pt-br/consumer/tls-connection.md b/content/pt-br/consumer/tls-connection.md
new file mode 100644
index 00000000..69108fb4
--- /dev/null
+++ b/content/pt-br/consumer/tls-connection.md
@@ -0,0 +1,80 @@
+---
+title: "TLS Connection"
+date: 2018-03-01T21:36:44-05:00
+description: ""
+categories: []
+keywords: []
+weight: 20
+aliases: []
+toc: false
+draft: false
+---
+
+A plataforma light suporta SSL de uma via por padrão no [light-codegen] [] e SSL de duas vias atualizando server.yml para ativar. A menos que você esteja usando algumas ferramentas antigas que não suportam HTTPS, recomenda-se usar pelo menos SSL unidirecional, mesmo na fase de desenvolvimento, para que você não tenha nenhuma surpresa ao liberar para um ambiente de teste oficial.
+
+### certificados TLS
+
+Existem quatro arquivos keystore que podem ser gerados a partir do light-codegen, dependendo do config.json no repositório model-config.
+
+Aqui está um exemplo de config.json para light-codegen.
+
+```
+{
+ "name": "apia",
+ "version": "1.0.0",
+ "groupId": "com.networknt",
+ "artifactId": "apia",
+ "rootPackage": "com.networknt.apia",
+ "handlerPackage":"com.networknt.apia.handler",
+ "modelPackage":"com.networknt.apia.model",
+ "overwriteHandler": true,
+ "overwriteHandlerTest": true,
+ "overwriteModel": true,
+ "httpPort": 7001,
+ "enableHttp": true,
+ "httpsPort": 7441,
+ "enableHttps": true,
+ "enableRegistry": false,
+ "supportDb": false,
+ "supportH2ForTest": false,
+ "supportClient": true
+}
+
+```
+Por padrão, o código gerado terá server.keystore e server.truststore na pasta de configuração. Mas se supportClient for true em config.json, o client.keystore e o client.truststore também serão gerados.
+
+Para obter informações sobre arquivos de armazenamento de chaves, consulte [armazenamento confiável de keystore][].
+
+Os keystores e truststores gerados contêm certificados auto-assinados expiram no ano de 2023 e devem ser usados apenas para desenvolvimento. Depois de passar para um ambiente de teste oficial, eles precisam ser substituídos por outros certificados auto-assinados ou certificados assinados pela CA.
+
+Por favor consulte o [certificado assinado por si mesmo vs assinado pela CA] [] para obter detalhes sobre quando usar o certificado autoassinado ou assinado pela CA.
+
+### Habilitar TLS direcional ou bidirecional
+
+Por favor consulte [server config][] para mais detalhes.
+
+### Download certificado do servidor
+
+Ao se conectar a um servidor com HTTPS, você deve solicitar o certificado de cliente do administrador do servidor. Se você não puder obter o certificado do administrador do servidor, poderá baixá-lo do servidor com o openssl.
+
+Por favor, consulte o tutorial [public https][] para mais detalhes.
+
+### Conexão de TLS modo Debug
+
+Ao fazer conexão TLS com o servidor, você precisa adicionar certificados ao client.truststore na maioria dos casos. Para a maioria dos desenvolvedores, pode ser um desafio fazer tudo certo na primeira vez. Se a conexão não for estabelecida com o servidor, é provável que você tenha o client.truststore sem o certificado do cliente. Para descobrir se o problema de conexão é devido ao certificado, você pode habilitar a depuração do tls em seu IDE.
+
+Aqui está um artigo que contém todos os detalhes em [Debugging SSL / TLS Connections][].
+
+Basicamente, você precisa colocar a seguinte opção JVM ao iniciar seu servidor no IDE.
+
+```
+-Djavax.net.debug=all
+```
+
+[keystore truststore]: /tutorial/security/keystore-truststore/
+[self-signed vs CA-signed certificate]: /faq/self-ca-signed-cert/
+[server config]: /concern/server/
+[light-codegen]: /tool/light-codegen/
+[public https]: /tutorial/client/public-https/
+[Debugging SSL/TLS Connections]: https://docs.oracle.com/javase/7/docs/technotes/guides/security/jsse/ReadDebug.html
+
diff --git a/content/pt-br/consumer/token-startup.md b/content/pt-br/consumer/token-startup.md
new file mode 100644
index 00000000..6381b1f9
--- /dev/null
+++ b/content/pt-br/consumer/token-startup.md
@@ -0,0 +1,11 @@
+---
+title: "Token Startup"
+date: 2018-03-01T21:38:25-05:00
+description: ""
+categories: []
+keywords: []
+weight: 80
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/traceability-id.md b/content/pt-br/consumer/traceability-id.md
new file mode 100644
index 00000000..90660c9f
--- /dev/null
+++ b/content/pt-br/consumer/traceability-id.md
@@ -0,0 +1,11 @@
+---
+title: "Traceability Id"
+date: 2018-03-01T21:39:11-05:00
+description: ""
+categories: []
+keywords: []
+weight: 110
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/traceability.md b/content/pt-br/consumer/traceability.md
new file mode 100644
index 00000000..2e2521d9
--- /dev/null
+++ b/content/pt-br/consumer/traceability.md
@@ -0,0 +1,11 @@
+---
+title: "Traceability"
+date: 2018-03-01T21:39:04-05:00
+description: ""
+categories: []
+keywords: []
+weight: 100
+aliases: []
+toc: false
+draft: false
+---
diff --git a/content/pt-br/consumer/vue.md b/content/pt-br/consumer/vue.md
new file mode 100644
index 00000000..d284af4c
--- /dev/null
+++ b/content/pt-br/consumer/vue.md
@@ -0,0 +1,15 @@
+---
+title: "Vue"
+date: 2018-12-24T19:47:51-05:00
+description: ""
+categories: []
+keywords: []
+slug: ""
+aliases: []
+toc: false
+draft: false
+---
+
+O Vue é uma estrutura progressiva para construir interfaces com o usuário. Ao contrário de outros frameworks monolíticos, o Vue é projetado desde o início para ser incrementalmente adotável. A biblioteca central é focada apenas na camada de visualização e é fácil de ser coletada e integrada a outras bibliotecas ou projetos existentes. Por outro lado, o Vue também é perfeitamente capaz de fornecer SPAs sofisticados quando usado em combinação com ferramentas modernas e bibliotecas de suporte.
+
+A seguir, uma lista de projetos de software livre que usam o Vue como interface do usuário.
\ No newline at end of file
diff --git a/content/pt-br/consumer/zookeeper-discovery.md b/content/pt-br/consumer/zookeeper-discovery.md
new file mode 100644
index 00000000..0d1c7e15
--- /dev/null
+++ b/content/pt-br/consumer/zookeeper-discovery.md
@@ -0,0 +1,16 @@
+---
+title: "Zookeeper Discovery"
+date: 2018-03-01T21:40:40-05:00
+description: ""
+categories: []
+keywords: []
+weight: 200
+aliases: []
+toc: false
+draft: false
+---
+
+O Apache Zookeeper pode ser usado como registro de serviço e descoberta com o módulo [zookeeper][] na light-4j; no entanto, não é recomendado, pois é muito pesado e lento. Ele só deve ser usado quando você já tiver o cluster implementado em casa e o número de serviços em execução for pequeno. Caso contrário, recomenda-se usar [Consul][] para registro e descoberta de serviço.
+
+[zookeeper]: /concern/zookeeper/
+[Consul]: /ptbr/consumer/consul-discovery/