spring-cloud__spring-cloud-config_CVE-2020-5405_2-1-6-RELEASE

//// NO EDITE ESTE ARCHIVO. FUE GENERADO. Los cambios manuales en este archivo se perderán cuando se genere de nuevo. Edite los archivos en el directorio src/main/asciidoc/ en su lugar. ////

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"]

Spring Cloud Config ofrece soporte del lado del servidor y del lado del cliente para la configuración externalizada en un sistema distribuido. Con el Config Server, dispone de un lugar central para gestionar las propiedades externas de las aplicaciones en todos los entornos. Los conceptos tanto en el cliente como en el servidor se corresponden de forma idéntica con las abstracciones Environment y PropertySource de Spring, por lo que encajan muy bien con las aplicaciones Spring, pero pueden utilizarse con cualquier aplicación que se ejecute en cualquier lenguaje. A medida que una aplicación avanza por el pipeline de despliegue desde desarrollo a pruebas y hasta producción, puede gestionar la configuración entre esos entornos y estar seguro de que las aplicaciones tienen todo lo que necesitan para ejecutarse cuando migran. La implementación predeterminada del backend de almacenamiento del servidor utiliza git, por lo que admite fácilmente versiones etiquetadas de entornos de configuración y, además, es accesible para una amplia variedad de herramientas de gestión del contenido. Es fácil añadir implementaciones alternativas y conectarlas mediante la configuración de Spring.

== Features

=== Spring Cloud Config Server

Spring Cloud Config Server ofrece las siguientes ventajas:

• API basada en recursos HTTP para la configuración externa (pares nombre-valor o contenido YAML equivalente)
• Cifrar y descifrar valores de propiedades (simétrico o asimétrico)
• Integrable fácilmente en una aplicación Spring Boot mediante @EnableConfigServer

=== Spring Cloud Config Client

Específicamente para aplicaciones Spring, Spring Cloud Config Client le permite:

• Vincularse al Config Server e inicializar el Environment de Spring con fuentes de propiedades remotas.
• Cifrar y descifrar valores de propiedades (simétrico o asimétrico).
• @RefreshScope para los @Beans de Spring que quieran reinicializarse cuando cambie la configuración.
• Usar endpoints de gestión: ** /env para actualizar el Environment y reenlazar @ConfigurationProperties y niveles de log. ** /refresh para refrescar los beans @RefreshScope. ** /restart para reiniciar el contexto de Spring (deshabilitado por defecto). ** /pause y /resume para invocar los métodos Lifecycle (stop() y en el ).

== Quick Start

Esta guía de inicio rápido explica cómo utilizar tanto el servidor como el cliente de Spring Cloud Config Server.

Primero, inicie el servidor, como se muestra a continuación:

$ cd spring-cloud-config-server $ ../mvnw spring-boot:run

El servidor es una aplicación Spring Boot, por lo que puede ejecutarlo desde su IDE si lo prefiere (la clase principal es ConfigServerApplication).

A continuación, pruebe un cliente, como se muestra a continuación:

$ curl localhost:8888/foo/development {"name":"foo","label":"master","propertySources":[ {"name":"https://github.com/scratches/config-repo/foo-development.properties","source":{"bar":"spam"}}, {"name":"https://github.com/scratches/config-repo/foo.properties","source":{"foo":"bar"}} ]}

La estrategia predeterminada para localizar fuentes de propiedades es clonar un repositorio git (en spring.cloud.config.server.git.uri) y utilizarlo para inicializar un mini SpringApplication. El Environment de la mini-aplicación se utiliza para enumerar las fuentes de propiedades y publicarlas en un endpoint JSON.

El servicio HTTP tiene recursos con el siguiente formato:

/{application}/{profile}[/{label}] /{application}-{profile}.yml /{label}/{application}-{profile}.yml /{application}-{profile}.properties /{label}/{application}-{profile}.properties

donde application se inyecta como spring.config.name en el SpringApplication (lo que normalmente es application en una aplicación Spring Boot estándar), profile es un perfil activo (o una lista de propiedades separadas por comas) y label es una etiqueta git opcional (por defecto, master).

Spring Cloud Config Server obtiene la configuración para los clientes remotos de diversas fuentes. El siguiente ejemplo obtiene configuración de un repositorio git (que debe proporcionarse), como se muestra a continuación:

[source,yaml]

spring: cloud: config: server: git: uri: https://github.com/spring-cloud-samples/config-repo

Otras fuentes son cualquier base de datos compatible con JDBC, Subversion, Hashicorp Vault, Credhub y sistemas de archivos locales.

=== Client Side Usage

=== Uso en el lado del cliente

Para usar estas características en una aplicación, puede crearla como una aplicación Spring Boot que dependa de spring-cloud-config-client (para ver un ejemplo, consulte los casos de prueba de config-client o la aplicación de muestra). La forma más cómoda de añadir la dependencia es con un starter de Spring Boot org.springframework.cloud:spring-cloud-starter-config. También hay un pom padre y un BOM (spring-cloud-starter-parent) para usuarios de Maven, y un archivo de propiedades de gestión de versiones de Spring IO para usuarios de Gradle y Spring CLI. El siguiente ejemplo muestra una configuración típica de Maven:

[source,xml,indent=0] .pom.xml

<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 -->

Ahora puede crear una aplicación Spring Boot estándar, como el siguiente 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);
}

}

Cuando este servidor HTTP se ejecuta, recoge la configuración externa del servidor de configuración local predeterminado (si está en ejecución) en el puerto 8888. Para modificar el comportamiento de inicio, puede cambiar la ubicación del servidor de configuración mediante bootstrap.properties (similar a application.properties, pero para la fase de bootstrap de un contexto de aplicación), como se muestra en el siguiente ejemplo:

spring.cloud.config.uri: http://myconfigserver.com

Por defecto, si no se establece ningún nombre de aplicación, se usará application. Para modificar el nombre, se puede añadir la siguiente propiedad al archivo bootstrap.properties:

spring.application.name: myapp

NOTA: Al establecer la propiedad ${spring.application.name}, no prefije el nombre de su aplicación con la palabra reservada application- para evitar problemas al resolver la fuente de propiedades correcta.

Las propiedades de bootstrap aparecen en el endpoint /env como una fuente de propiedades de alta prioridad, como se muestra en el siguiente ejemplo.

$ curl localhost:8080/env { "profiles":[], "configService:https://github.com/spring-cloud-samples/config-repo/bar.properties":{"foo":"bar"}, "servletContextInitParams":{}, "systemProperties":{...}, ... }

Una fuente de propiedades llamada ```configService:/contiene la propiedadfoocon un valor debar` y tiene la máxima prioridad.

NOTA: La URL en el nombre de la fuente de propiedades es el repositorio git, no la URL del servidor de configuración.

=== Sample Application

=== Aplicación de muestra

Puede encontrar una aplicación de muestra https://github.com/spring-cloud/spring-cloud-config/tree/master/spring-cloud-config-sample[aquí]. Es una aplicación Spring Boot, por lo que puede ejecutarla mediante los mecanismos habituales (por ejemplo, mvn spring-boot:run). Cuando se ejecuta, busca el servidor de configuración en http://localhost:8888 (un valor predeterminado configurable), por lo que también puede ejecutar el servidor para ver cómo funciona todo en conjunto.

La muestra tiene un caso de prueba en el que el servidor de configuración también se inicia en el mismo JVM (con un puerto diferente), y la prueba verifica que una propiedad de entorno del repositorio de configuración git está presente. Para cambiar la ubicación del servidor de configuración, puede establecer spring.cloud.config.uri en bootstrap.yml (o en propiedades del sistema y otros lugares).

El caso de prueba tiene un método main() que ejecuta el servidor de la misma manera (observe los registros para conocer su puerto), por lo que puede ejecutar todo el sistema en un solo proceso y experimentar con él (por ejemplo, puede ejecutar el método main() en su IDE). El método main() usa target/config como directorio de trabajo del repositorio git, por lo que puede hacer cambios locales allí y verlos reflejados en la aplicación en ejecución. El siguiente ejemplo muestra una sesión de pruebas con el caso de prueba:

$ curl localhost:8080/env/sample mytest $ vi target/config/mytest.properties .. change value of "sample", optionally commit $ curl localhost:8080/refresh ["sample"] $ curl localhost:8080/env/sample sampleValue

El endpoint de refresh informa de que la propiedad "sample" ha cambiado.

== Building

:jdkversion: 1.7

=== Basic Compile and Test

=== Compilación y prueba básicas

Para compilar el código fuente necesitará instalar JDK {jdkversion}.

Spring Cloud utiliza Maven para la mayoría de las actividades relacionadas con la compilación, y debería poder empezar rápidamente clonando el proyecto que le interese y escribiendo

$ ./mvnw install

NOTA: También puede instalar Maven (>=3.3.3) por su cuenta y ejecutar el comando mvn en lugar de ./mvnw en los ejemplos siguientes. Si hace eso, también es posible que necesite añadir -P spring si su configuración local de Maven no contiene declaraciones de repositorio para los artefactos de pre-lanzamiento de Spring.

NOTA: Tenga en cuenta que es posible que necesite aumentar la cantidad de memoria disponible para Maven estableciendo una variable de entorno MAVEN_OPTS con un valor como -Xmx512m -XX:MaxPermSize=128m. Intentamos cubrir esto en la configuración de .mvn, así que si tiene que hacerlo para que una compilación tenga éxito, por favor abra un ticket para que los ajustes se añadan al control de código fuente.

Para obtener pistas sobre cómo compilar el proyecto, mire en .travis.yml si existe. Debería haber un comando "script" y quizás "install". También mire la sección "services" para ver si algún servicio necesita ejecutarse localmente (por ejemplo, mongo o rabbit). Ignore las partes relacionadas con git que pueda encontrar en "before_install", ya que están relacionadas con la configuración de credenciales git y usted ya las tiene.

Los proyectos que requieren middleware generalmente incluyen un docker-compose.yml, por lo que considere usar https://docs.docker.com/compose/[Docker Compose] para ejecutar los servidores de middleware en contenedores Docker. Consulte el README en el https://github.com/spring-cloud-samples/scripts[repositorio de demostración de scripts] para obtener instrucciones específicas sobre los casos habituales de mongo, rabbit y redis.

NOTA: Si todo lo demás falla, compile con el comando de .travis.yml (normalmente ./mvnw install).

=== Documentation

=== Documentación

El módulo spring-cloud-build tiene un perfil "docs" y, si lo activa, intentará compilar las fuentes asciidoc de src/main/asciidoc. Como parte de ese proceso, buscará un README.adoc y lo procesará cargando todos los includes, pero sin analizarlo ni renderizarlo, solo copiándolo a ${main.basedir} (por defecto, ${basedir}, es decir, la raíz del proyecto). Si hay algún cambio en el README, aparecerá después de una compilación de Maven como un archivo modificado en el lugar correcto. Simplemente confírmelo y envíe el cambio.

=== Working with the code

=== Trabajar con el código

Si no tiene preferencia por un IDE, le recomendamos que use https://www.springsource.com/developer/sts[Spring Tools Suite] o https://eclipse.org[Eclipse] cuando trabaje con el código. Usamos el plugin de Eclipse https://eclipse.org/m2e/[m2eclipse] para el soporte de Maven. Otros IDEs y herramientas también deberían funcionar sin problemas siempre que usen Maven 3.3.3 o superior.

==== Importing into eclipse with m2eclipse

==== Importación en Eclipse con m2eclipse

Recomendamos el plugin de Eclipse https://eclipse.org/m2e/[m2eclipse] cuando trabaje con Eclipse. Si aún no tiene m2eclipse instalado, está disponible en el "mercado de Eclipse" (eclipse marketplace).

NOTA: Las versiones antiguas de m2e no son compatibles con Maven 3.3, por lo que, una vez importados los proyectos en Eclipse, también tendrá que indicar a m2eclipse que use el perfil correcto para los proyectos. Si ve muchos errores diferentes relacionados con los POMs en los proyectos, compruebe que tiene una instalación actualizada. Si no puede actualizar m2e, añada el perfil "spring" a su settings.xml. Alternativamente, puede copiar los ajustes de repositorio del perfil "spring" del pom padre en su settings.xml.

==== Importing into eclipse without m2eclipse

==== Importación en Eclipse sin m2eclipse

Si prefiere no usar m2eclipse, puede generar los metadatos del proyecto Eclipse con el siguiente comando:

[indent=0]

$ ./mvnw eclipse:eclipse

Los proyectos Eclipse generados pueden importarse seleccionando import existing projects en el menú file.

=== JCE

Si recibe una excepción debida a "Illegal key size" y está usando el JDK de Sun, debe instalar los archivos de política de jurisdicción de fuerza ilimitada de la extensión de criptografía de Java (JCE). Consulte los siguientes enlaces para obtener más información:

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]

Extraiga los archivos JCE en la carpeta JDK/jre/lib/security correspondiente a la versión de JRE/JDK x64/x86 que use.

== Contributing

:spring-cloud-build-branch: master

Spring Cloud se publica bajo la licencia Apache 2.0 no restrictiva y sigue un proceso de desarrollo de Github muy estándar, utilizando el rastreador de Github para los problemas y fusionando las pull requests en master. Si quiere contribuir incluso con algo trivial, no lo dude, pero siga las pautas que se indican a continuación.

=== Sign the Contributor License Agreement

=== Firme el Acuerdo de Licencia de Colaborador

Antes de aceptar un parche o pull request no trivial, necesitaremos que firme el https://cla.pivotal.io/sign/spring[Acuerdo de Licencia de Colaborador]. Firmar el acuerdo del colaborador no otorga a nadie derechos de commit sobre el repositorio principal, pero sí significa que podemos aceptar sus contribuciones, y recibirá un crédito de autor si lo hacemos. Es posible que se pida a los colaboradores activos que se unan al equipo principal y se les dé la capacidad de fusionar pull requests.

=== Code of Conduct

=== Código de conducta

Este proyecto se adhiere al https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[código de conducta] del Contributor Covenant. Al participar, se espera que cumpla este código. Informe de cualquier comportamiento inaceptable a [email protected].

=== Code Conventions and Housekeeping

=== Convenciones de código y mantenimiento

Ninguna de estas cosas es esencial para una pull request, pero todas ayudan. También pueden añadirse después de la pull request original, pero antes de una fusión.

• Use las convenciones de formato de código de Spring Framework. Si usa Eclipse, puede importar los ajustes de formato con el archivo eclipse-code-formatter.xml del proyecto https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring Cloud Build]. Si usa IntelliJ, puede utilizar el https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter Plugin] para importar el mismo archivo.
• Asegúrese de que todos los archivos .java nuevos tengan un comentario de clase Javadoc simple con al menos una etiqueta @author que le identifique y, preferiblemente, al menos un párrafo sobre para qué sirve la clase.
• Añada el comentario de cabecera de licencia ASF a todos los archivos .java nuevos (cópielo de los archivos existentes del proyecto).
• Añádase como @author en los archivos .java que modifique de forma sustancial (más que cambios cosméticos).
• Añada algunos Javadocs y, si cambia el espacio de nombres, algunos elementos de documentación XSD.
• Unas pocas pruebas unitarias también ayudarían mucho: alguien tiene que hacerlo.
• Si nadie más está usando su rama, haga rebase contra la rama master actual (u otra rama destino del proyecto principal).
• Al escribir un mensaje de commit, siga https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[estas convenciones]; si está corrigiendo un problema existente, añada al final del mensaje de commit (donde XXXX es el número del problema).

=== Checkstyle

=== Checkstyle

Spring Cloud Build incluye un conjunto de reglas de checkstyle. Puede encontrarlas en el módulo spring-cloud-build-tools. Los archivos más destacados del módulo son:

.spring-cloud-build-tools/

└── src    ├── checkstyle    │   └── checkstyle-suppressions.xml <3>    └── main    └── resources    ├── checkstyle-header.txt <2>    └── checkstyle.xml <1>

<1> Reglas de Checkstyle predeterminadas <2> Configuración de la cabecera de archivo <3> Reglas de supresión predeterminadas

==== Checkstyle configuration

==== Configuración de Checkstyle

Las reglas de Checkstyle están deshabilitadas por defecto. Para añadir checkstyle a su proyecto, simplemente defina las siguientes propiedades y plugins.

.pom.xml

<reporting>
    <plugins>
        <plugin> <5>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-checkstyle-plugin</artifactId>
        </plugin>
    </plugins>
</reporting>

Si necesita suprimir algunas reglas (por ejemplo, si la longitud de línea debe ser mayor), basta con que defina un archivo en ${project.root}/src/checkstyle/checkstyle-suppressions.xml con sus supresiones. Ejemplo:.projectRoot/src/checkstyle/checkstyle-suppresions.xml

Es recomendable copiar ${spring-cloud-build.rootFolder}/.editorconfig y ${spring-cloud-build.rootFolder}/.springformat a tu proyecto. De esa manera, se aplicarán algunas reglas de formato predeterminadas. Puedes hacerlo ejecutando este script:```bash $ curl https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/.editorconfig -o .editorconfig $ touch .springformat

=== Configuración del IDE

==== Intellij IDEA

Para configurar Intellij, debes importar nuestras convenciones de codificación, perfiles de inspección y configurar el plugin de checkstyle.
Los siguientes archivos se pueden encontrar en el proyecto 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> Reglas de Checkstyle predeterminadas
<2> Configuración de la cabecera de archivo
<3> Reglas de supresión predeterminadas
<4> Valores predeterminados del proyecto para Intellij que aplican la mayoría de las reglas de Checkstyle
<5> Convenciones de estilo del proyecto para Intellij que aplican la mayoría de las reglas de 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]

Ve a `File` -> `Settings` -> `Editor` -> `Code style`. Haz clic en el icono junto a la sección `Scheme`. Allí, haz clic en el valor `Import Scheme` y elige la opción `Intellij IDEA code style XML`. Importa el archivo `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Spring_Boot_Java_Conventions.xml`.

.Perfiles de inspección

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]

Ve a `File` -> `Settings` -> `Editor` -> `Inspections`. Haz clic en el icono junto a la sección `Profile`. Allí, haz clic en `Import Profile` e importa el archivo `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Project_Defaults.xml`.

.Checkstyle

Para que Intellij funcione con Checkstyle, debes instalar el plugin `Checkstyle`. También es recomendable instalar `Assertions2Assertj` para convertir automáticamente las aserciones de JUnit.

image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-checkstyle.png[Checkstyle]

Ve a `File` -> `Settings` -> `Other settings` -> `Checkstyle`. Haz clic en el icono `+` en la sección `Configuration file`. Allí tendrás que definir de dónde se deben tomar las reglas de checkstyle. En la imagen anterior, hemos tomado las reglas del repositorio clonado de Spring Cloud Build. Sin embargo, puedes apuntar al repositorio de GitHub de Spring Cloud Build (p. ej. para `checkstyle.xml` : `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle.xml`). Necesitamos proporcionar las siguientes variables:

- `checkstyle.header.file` - apunta al archivo `spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` de Spring Cloud Build, ya sea en tu repositorio clonado o mediante la URL `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle-header.txt`.
- `checkstyle.suppressions.file` - supresiones predeterminadas. Apunta al archivo `spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` de Spring Cloud Build, ya sea en tu repositorio clonado o mediante la 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 variable corresponde a las supresiones en tu proyecto local. Por ejemplo, si estás trabajando en `spring-cloud-contract`, apunta a la carpeta `project-root/src/checkstyle/checkstyle-suppressions.xml`. Un ejemplo para `spring-cloud-contract` sería: `/home/username/spring-cloud-contract/src/checkstyle/checkstyle-suppressions.xml`.

IMPORTANT: Recuerda establecer `Scan Scope` en `All sources` ya que aplicamos las reglas de checkstyle para las fuentes de producción y prueba.