shoucheng3/spring-cloud__spring-cloud-config_cve-2020-5410_2-1-8-releaseServidor de configuração centralizado para sistemas distribuídos com API HTTP, armazenamento baseado em Git, criptografia/descriptografia de propriedades e integração com Vault, JDBC e sistemas de arquivos locais.
//// NÃO EDITE ESTE ARQUIVO. ELE FOI GERADO. Alterações manuais neste arquivo serão perdidas quando ele for gerado novamente. Edite os arquivos no diretório src/main/asciidoc/ em vez disso. ////
image::https://circleci.com/gh/spring-cloud/spring-cloud-config/tree/master.svg?style=svg["CircleCI", link="https://circleci.com/gh/spring-cloud/spring-cloud-config/tree/master"] image::https://codecov.io/gh/spring-cloud/spring-cloud-config/branch/master/graph/badge.svg["Codecov", link="https://codecov.io/gh/spring-cloud/spring-cloud-config/branch/master"] image::https://api.codacy.com/project/badge/Grade/f064024a072c477e97dca6ed5a70fccd?branch=master["Codacy code quality", link="https://www.codacy.com/app/Spring-Cloud/spring-cloud-config?branch=master&utm_source=github.com&utm_medium=referral&utm_content=spring-cloud/spring-cloud-config&utm_campaign=Badge_Grade"]
O Spring Cloud Config fornece suporte no lado do servidor e no lado do cliente para configuração externalizada em um sistema distribuído. Com o Config Server, você tem um lugar central para gerenciar propriedades externas de aplicações em todos os ambientes.
Os conceitos no cliente e no servidor mapeiam de forma idêntica para as abstrações Environment e PropertySource do Spring, portanto eles se encaixam muito bem com aplicações Spring, mas podem ser usados com qualquer aplicação executada em qualquer linguagem.
Conforme uma aplicação avança pelo pipeline de implantação, de desenvolvimento para teste e para produção, você pode gerenciar a configuração entre esses ambientes e ter a certeza de que as aplicações têm tudo de que precisam para executar quando migram.
A implementação padrão do backend de armazenamento do servidor usa git, portanto ela suporta facilmente versões rotuladas de ambientes de configuração, além de ser acessível a uma ampla variedade de ferramentas para gerenciar o conteúdo.
É fácil adicionar implementações alternativas e conectá-las com a configuração do Spring.
== Recursos
=== Spring Cloud Config Server
O Spring Cloud Config Server oferece os seguintes benefícios:
@EnableConfigServer=== Spring Cloud Config Client
Especificamente para aplicações Spring, o Spring Cloud Config Client permite que você:
Environment do Spring com fontes de propriedades remotas.@RefreshScope para @Beans do Spring que desejam ser reinicializados quando a configuração mudar./env para atualizar o Environment e religar @ConfigurationProperties e níveis de log.
** /refresh para atualizar os beans @RefreshScope.
** /restart para reiniciar o contexto do Spring (desabilitado por padrão).
** /pause e /resume para chamar os métodos Lifecycle (stop() e no ).== Início Rápido
Este início rápido mostra o uso do servidor e do cliente do Spring Cloud Config Server.
Primeiro, inicie o servidor, da seguinte forma:
O servidor é uma aplicação Spring Boot, portanto você pode executá-lo a partir da sua IDE, se preferir (a classe principal é ConfigServerApplication).
Em seguida, experimente um cliente, da seguinte forma:
A estratégia padrão para localizar fontes de propriedades é clonar um repositório git (em spring.cloud.config.server.git.uri) e usá-lo para inicializar uma mini SpringApplication.
O Environment da mini-aplicação é usado para enumerar as fontes de propriedades e publicá-las em um endpoint JSON.
O serviço HTTP tem recursos na seguinte forma:
onde application é injetada como spring.config.name na SpringApplication (o que normalmente é application em uma aplicação Spring Boot comum), profile é um perfil ativo (ou uma lista de propriedades separada por vírgulas), e label é um rótulo git opcional (o padrão é master.)
O Spring Cloud Config Server obtém configuração para clientes remotos de várias fontes. O exemplo a seguir mostra como obter configuração de um repositório git (que deve ser fornecido):
Outras fontes são qualquer banco de dados compatível com JDBC, Subversion, Hashicorp Vault, Credhub e sistemas de arquivos locais.
=== Uso no Lado do Cliente
Para usar esses recursos em uma aplicação, você pode construí-la como uma aplicação Spring Boot que depende de spring-cloud-config-client (para um exemplo, veja os casos de teste do config-client ou a aplicação de exemplo).
A maneira mais conveniente de adicionar a dependência é com um starter Spring Boot org.springframework.cloud:spring-cloud-starter-config.
Também há um pom pai e um BOM (spring-cloud-starter-parent) para usuários de Maven e um arquivo de propriedades de gerenciamento de versões do Spring IO para usuários de Gradle e Spring CLI. O exemplo a seguir mostra uma configuração Maven típica:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>{spring-boot-docs-version}</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>{spring-cloud-version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<!-- repositories also needed for snapshots and milestones -->
Agora você pode criar uma aplicação Spring Boot padrão, como o seguinte servidor HTTP:
@SpringBootApplication @RestController public class Application {
@RequestMapping("/")
public String home() {
return "Hello World!";
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
Quando esse servidor HTTP é executado, ele capta a configuração externa do servidor de configuração local padrão (se estiver em execução) na porta 8888.
Para modificar o comportamento de inicialização, você pode alterar a localização do servidor de configuração usando bootstrap.properties (semelhante a application.properties, mas para a fase de bootstrap de um contexto de aplicação), como mostrado no exemplo a seguir:
Por padrão, se nenhum nome de aplicação for definido, application será usado. Para modificar o nome, a seguinte propriedade pode ser adicionada ao arquivo bootstrap.properties:
NOTE: Ao definir a propriedade ${spring.application.name}, não prefixe o nome da sua aplicação com a palavra reservada application- para evitar problemas ao resolver a fonte de propriedades correta.
As propriedades bootstrap aparecem no endpoint /env como uma fonte de propriedades de alta prioridade, como mostrado no exemplo a seguir.
Uma fonte de propriedades chamada ```configService:/contém a propriedadefoocom o valorbar` e tem a prioridade mais alta.
NOTE: A URL no nome da fonte de propriedades é o repositório git, não a URL do servidor de configuração.
=== Aplicação de Exemplo
Você pode encontrar uma aplicação de exemplo https://github.com/spring-cloud/spring-cloud-config/tree/master/spring-cloud-config-sample[aqui].
Ela é uma aplicação Spring Boot, portanto você pode executá-la usando os mecanismos usuais (por exemplo, mvn spring-boot:run).
Quando executada, ela procura o servidor de configuração em http://localhost:8888 (um padrão configurável), então você também pode executar o servidor para ver tudo funcionando em conjunto.
A aplicação de exemplo tem um caso de teste em que o servidor de configuração também é iniciado na mesma JVM (com uma porta diferente), e o teste verifica se uma propriedade de ambiente do repositório de configuração git está presente.
Para alterar a localização do servidor de configuração, você pode definir spring.cloud.config.uri em bootstrap.yml (ou em propriedades de sistema e outros lugares).
O caso de teste tem um método main() que executa o servidor da mesma maneira (veja os logs para descobrir a porta), então você pode executar todo o sistema em um único processo e brincar com ele (por exemplo, você pode executar o método main() na sua IDE).
O método main() usa target/config como diretório de trabalho do repositório git, então você pode fazer alterações locais lá e vê-las refletidas na aplicação em execução. O exemplo a seguir mostra uma sessão de experimentação com o caso de teste:
O endpoint de refresh informa que a propriedade "sample" mudou.
== Compilação
:jdkversion: 1.7
=== Compilação e Teste Básicos
Para compilar o código-fonte, você precisará instalar o JDK {jdkversion}.
O Spring Cloud usa Maven para a maioria das atividades relacionadas à compilação, e você deve conseguir começar rapidamente clonando o projeto em que está interessado e digitando
NOTE: Você também pode instalar o Maven (>=3.3.3) por conta própria e executar o comando mvn
no lugar de ./mvnw nos exemplos abaixo. Se fizer isso, talvez
também seja necessário adicionar -P spring se as suas configurações locais do Maven não
contiverem declarações de repositório para artefatos de pré-lançamento do Spring.
NOTE: Esteja ciente de que talvez seja necessário aumentar a quantidade de memória
disponível para o Maven definindo uma variável de ambiente MAVEN_OPTS com
um valor como -Xmx512m -XX:MaxPermSize=128m. Tentamos cobrir isso na
configuração .mvn, portanto, se você precisar fazer isso para que a
compilação seja bem-sucedida, abra um chamado para que as configurações sejam adicionadas
ao controle de versão.
Para dicas sobre como compilar o projeto, consulte o .travis.yml, se houver
um. Deve haver um comando "script" e talvez "install". Além disso,
verifique a seção "services" para ver se algum serviço precisa estar
em execução localmente (por exemplo, mongo ou rabbit). Ignore as partes relacionadas ao git
que você possa encontrar em "before_install", pois elas estão relacionadas à definição de credenciais git
e você já as tem.
Os projetos que exigem middleware geralmente incluem um
docker-compose.yml, portanto considere usar o
https://docs.docker.com/compose/[Docker Compose] para executar os servidores de middleware
em contêineres Docker. Consulte o README no
https://github.com/spring-cloud-samples/scripts[repositório de demonstração
de scripts] para obter instruções específicas sobre os casos comuns de mongo,
rabbit e redis.
NOTE: Se tudo mais falhar, compile com o comando do .travis.yml (geralmente
./mvnw install).
=== Documentação
O módulo spring-cloud-build tem um perfil "docs" e, se você ativá-lo,
ele tentará compilar as fontes asciidoc de
src/main/asciidoc. Como parte desse processo, ele procurará um
README.adoc e o processará carregando todos os includes, mas sem
analisá-lo ou renderizá-lo, apenas copiando-o para ${main.basedir}
(o padrão é ${basedir}, ou seja, a raiz do projeto). Se houver
quaisquer alterações no README, elas aparecerão após uma compilação Maven como
um arquivo modificado no local correto. Basta fazer o commit e enviar a alteração.
=== Trabalhando com o código Se você não tiver preferência de IDE, recomendamos que use o https://www.springsource.com/developer/sts[Spring Tools Suite] ou o https://eclipse.org[Eclipse] ao trabalhar com o código. Usamos o plugin https://eclipse.org/m2e/[m2eclipse] do Eclipse para suporte ao Maven. Outras IDEs e ferramentas também devem funcionar sem problemas, desde que usem Maven 3.3.3 ou superior.
==== Importando para o Eclipse com m2eclipse Recomendamos o plugin https://eclipse.org/m2e/[m2eclipse] do Eclipse ao trabalhar com o Eclipse. Se você ainda não tiver o m2eclipse instalado, ele está disponível no "eclipse marketplace".
NOTE: Versões mais antigas do m2e não suportam o Maven 3.3, portanto, depois que os
projetos forem importados para o Eclipse, você também precisará informar ao
m2eclipse para usar o perfil correto para os projetos. Se você
vir muitos erros diferentes relacionados aos POMs nos projetos, verifique
se você tem uma instalação atualizada. Se você não puder atualizar o m2e,
adicione o perfil "spring" ao seu settings.xml. Alternativamente, você pode
copiar as configurações de repositório do perfil "spring" do pom
pai para o seu settings.xml.
==== Importando para o Eclipse sem m2eclipse Se você preferir não usar o m2eclipse, pode gerar os metadados do projeto Eclipse usando o seguinte comando:
$ ./mvnw eclipse:eclipse
Os projetos Eclipse gerados podem ser importados selecionando import existing projects
no menu file.
=== JCE
Se você receber uma exceção devido a "Illegal key size" e estiver usando o JDK da Sun, precisará instalar os Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files. Consulte os seguintes links para obter mais informações:
https://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html[Java 6 JCE]
https://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html[Java 7 JCE]
https://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html[Java 8 JCE]
Extraia os arquivos JCE para a pasta JDK/jre/lib/security de qualquer versão de JRE/JDK x64/x86 que você use.
== Contribuindo
:spring-cloud-build-branch: master
O Spring Cloud é distribuído sob a licença Apache 2.0, não restritiva, e segue um processo de desenvolvimento Github muito padrão, usando o tracker de issues do Github e mesclando pull requests na branch master. Se você quiser contribuir até mesmo com algo trivial, não hesite, mas siga as diretrizes abaixo.
=== Assine o Contrato de Licença de Contribuidor Antes de aceitarmos um patch ou pull request não trivial, precisaremos que você assine o https://cla.pivotal.io/sign/spring[Contrato de Licença de Contribuidor]. Assinar o contrato do contribuidor não concede a ninguém direitos de commit no repositório principal, mas significa que podemos aceitar suas contribuições, e você receberá um crédito de autor se o fizermos. Contribuidores ativos podem ser convidados a entrar para a equipe principal e receber a capacidade de mesclar pull requests.
=== Código de Conduta Este projeto adere ao https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[código de conduta] do Contributor Covenant. Ao participar, espera-se que você cumpra este código. Denuncie comportamentos inaceitáveis para [email protected].
=== Convenções de Código e Manutenção Nenhuma dessas é essencial para um pull request, mas todas ajudam. Elas também podem ser adicionadas após o pull request original, mas antes de uma mesclagem.
eclipse-code-formatter.xml do
projeto https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring
Cloud Build]. Se usar o IntelliJ, você pode usar o
https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter
Plugin] para importar o mesmo arquivo..java tenham um comentário de classe Javadoc simples com pelo menos uma
tag @author identificando você e, de preferência, pelo menos um parágrafo sobre para que serve a classe..java (copie dos arquivos existentes
no projeto)@author nos arquivos .java que você modificar substancialmente (mais
do que alterações cosméticas).Fixes gh-XXXX ao final da mensagem
de commit (onde XXXX é o número do problema).=== Checkstyle
O Spring Cloud Build vem com um conjunto de regras de checkstyle. Você pode encontrá-las no módulo spring-cloud-build-tools. Os arquivos mais notáveis do módulo são:
<1> Regras padrão do Checkstyle <2> Configuração do cabeçalho do arquivo <3> Regras padrão de supressão
==== Configuração do Checkstyle
As regras do Checkstyle estão desabilitadas por padrão. Para adicionar o checkstyle ao seu projeto, basta definir as seguintes propriedades e plugins.
<reporting>
<plugins>
<plugin> <5>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
</plugin>
</plugins>
</reporting>
${project.root}/src/checkstyle/checkstyle-suppressions.xml com as suas supressões. Exemplo:.projectRoot/src/checkstyle/checkstyle-suppresions.xmlÉ aconselhável copiar o ${spring-cloud-build.rootFolder}/.editorconfig e o ${spring-cloud-build.rootFolder}/.springformat para o seu projeto. Dessa forma, algumas regras de formatação padrão serão aplicadas. Você pode fazer isso executando este script:```bash
$ curl https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/.editorconfig -o .editorconfig
$ touch .springformat
=== Configuração da IDE
==== Intellij IDEA
Para configurar o Intellij, você deve importar nossas convenções de codificação, perfis de inspeção e configurar o plugin Checkstyle.
Os seguintes arquivos podem ser encontrados no projeto https://github.com/spring-cloud/spring-cloud-build/tree/master/spring-cloud-build-tools[Spring Cloud Build].
.spring-cloud-build-tools/
----
└── src
├── checkstyle
│ └── checkstyle-suppressions.xml <3>
└── main
└── resources
├── checkstyle-header.txt <2>
├── checkstyle.xml <1>
└── intellij
├── Intellij_Project_Defaults.xml <4>
└── Intellij_Spring_Boot_Java_Conventions.xml <5>
----
<1> Regras padrão do Checkstyle
<2> Configuração do cabeçalho do arquivo
<3> Regras de supressão padrão
<4> Padrões de projeto para Intellij que aplicam a maioria das regras Checkstyle
<5> Convenções de estilo de projeto para Intellij que aplicam a maioria das regras Checkstyle
.Estilo de código
image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-code-style.png[Estilo de código]
Vá em `File` -> `Settings` -> `Editor` -> `Code style`. Lá, clique no ícone ao lado da seção `Scheme`. Em seguida, clique no valor `Import Scheme` e escolha a opção `Intellij IDEA code style XML`. Importe o arquivo `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Spring_Boot_Java_Conventions.xml`.
.Perfis de inspeção
image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-inspections.png[Estilo de código]
Vá em `File` -> `Settings` -> `Editor` -> `Inspections`. Lá, clique no ícone ao lado da seção `Profile`. Em seguida, clique em `Import Profile` e importe o arquivo `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Project_Defaults.xml`.
.Checkstyle
Para fazer o Intellij funcionar com Checkstyle, você precisa instalar o plugin `Checkstyle`. É aconselhável também instalar o `Assertions2Assertj` para converter automaticamente as asserções JUnit
image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-checkstyle.png[Checkstyle]
Vá em `File` -> `Settings` -> `Other settings` -> `Checkstyle`. Lá, clique no ícone `+` na seção `Configuration file`. Então, você precisará definir de onde as regras de checkstyle devem ser obtidas. Na imagem acima, escolhemos as regras do repositório clonado do Spring Cloud Build. No entanto, você pode apontar para o repositório GitHub do Spring Cloud Build (por exemplo, para o `checkstyle.xml` : `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle.xml`). Precisamos fornecer as seguintes variáveis:
- `checkstyle.header.file` - por favor, aponte-o para o arquivo `spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` do Spring Cloud Build, seja no seu repositório clonado ou via URL `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle-header.txt`.
- `checkstyle.suppressions.file` - supressões padrão. Por favor, aponte-o para o arquivo `spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` do Spring Cloud Build, seja no seu repositório clonado ou via URL `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml`.
- `checkstyle.additional.suppressions.file` - esta variável corresponde às supressões no seu projeto local. Por exemplo, se você está trabalhando no `spring-cloud-contract`. Então aponte para a pasta `project-root/src/checkstyle/checkstyle-suppressions.xml`. Um exemplo para o `spring-cloud-contract` seria: `/home/username/spring-cloud-contract/src/checkstyle/checkstyle-suppressions.xml`.
IMPORTANTE: Lembre-se de definir o `Scan Scope` para `All sources`, pois aplicamos regras de checkstyle para fontes de produção e teste.
start()ApplicationContext