//// NON MODIFICARE QUESTO FILE. È STATO GENERATO. Le modifiche manuali a questo file andranno perse quando verrà generato nuovamente. Modifica invece i file nella directory src/main/asciidoc/. ////

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 fornisce supporto lato server e lato client per la configurazione esternalizzata in un sistema distribuito. Con il Config Server si dispone di un punto centrale per gestire le proprietà esterne delle applicazioni in tutti gli ambienti. I concetti sia sul client sia sul server corrispondono in modo identico alle astrazioni Spring Environment e PropertySource, quindi si integrano molto bene con le applicazioni Spring, ma possono essere utilizzati con qualsiasi applicazione eseguita in qualsiasi linguaggio. Quando un'applicazione attraversa la pipeline di distribuzione dallo sviluppo al test e alla produzione, puoi gestire la configurazione tra questi ambienti e avere la certezza che le applicazioni dispongano di tutto ciò di cui hanno bisogno per essere eseguite quando migrano. L'implementazione predefinita del backend di archiviazione del server usa git, quindi supporta facilmente versioni etichettate degli ambienti di configurazione ed è accessibile a un'ampia gamma di strumenti per la gestione del contenuto. È facile aggiungere implementazioni alternative e integrarle tramite la configurazione Spring.

== Funzionalità

=== Spring Cloud Config Server

Spring Cloud Config Server offre i seguenti vantaggi:

API basata su risorse HTTP per la configurazione esterna (coppie nome-valore o contenuto YAML equivalente)
Cifratura e decifratura dei valori delle proprietà (simmetrica o asimmetrica)
Facilmente incorporabile in un'applicazione Spring Boot usando @EnableConfigServer

=== Spring Cloud Config Client

Nello specifico per le applicazioni Spring, Spring Cloud Config Client consente di:

Associarsi al Config Server e inizializzare l'Environment Spring con property source remote.
Cifrare e decifrare i valori delle proprietà (simmetrica o asimmetrica).
Usare @RefreshScope per i @Beans Spring che devono essere re-inizializzati quando la configurazione cambia.
Usare endpoint di gestione: ** /env per aggiornare l'Environment e riassociare @ConfigurationProperties e livelli di log. ** /refresh per aggiornare i bean @RefreshScope. ** /restart per riavviare il contesto Spring (disabilitato per impostazione predefinita). ** /pause e /resume per chiamare i metodi Lifecycle (stop() e sull').

== Avvio rapido

Questa guida rapida illustra l'utilizzo sia del server sia del client di Spring Cloud Config Server.

Per prima cosa, avvia il server, come segue:

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

Il server è un'applicazione Spring Boot, quindi puoi eseguirlo dal tuo IDE se preferisci (la classe principale è ConfigServerApplication).

Successivamente prova un client, come segue:

$ 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 strategia predefinita per individuare le property source è clonare un repository git (in spring.cloud.config.server.git.uri) e usarlo per inizializzare una mini SpringApplication. L'Environment della mini-applicazione viene utilizzato per enumerare le property source e pubblicarle su un endpoint JSON.

Il servizio HTTP espone risorse nella forma seguente:

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

dove application viene iniettato come spring.config.name nella SpringApplication (quello che normalmente è application in una normale applicazione Spring Boot), profile è un profilo attivo (o un elenco di proprietà separate da virgole) e label è un'etichetta git opzionale (il valore predefinito è master.)

Spring Cloud Config Server recupera la configurazione per i client remoti da varie fonti. L'esempio seguente recupera la configurazione da un repository git (che deve essere fornito), come mostrato nell'esempio seguente:

[source,yaml]

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

Altre fonti sono qualsiasi database compatibile con JDBC, Subversion, Hashicorp Vault, Credhub e file system locali.

=== Utilizzo lato client

Per utilizzare queste funzionalità in un'applicazione, puoi realizzarla come applicazione Spring Boot che dipende da spring-cloud-config-client (per un esempio, consulta i casi di test per config-client o l'applicazione di esempio). Il modo più comodo per aggiungere la dipendenza è tramite uno starter Spring Boot org.springframework.cloud:spring-cloud-starter-config. Esiste anche un parent pom e una BOM (spring-cloud-starter-parent) per gli utenti Maven e un file di proprietà per la gestione delle versioni Spring IO per gli utenti Gradle e Spring CLI. L'esempio seguente mostra una tipica configurazione 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 -->

Ora puoi creare una standard applicazione Spring Boot, come il seguente server 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 questo server HTTP viene eseguito, recupera la configurazione esterna dal config server locale predefinito (se è in esecuzione) sulla porta 8888. Per modificare il comportamento di avvio, puoi cambiare la posizione del config server utilizzando bootstrap.properties (simile a application.properties ma per la fase di bootstrap di un contesto applicativo), come mostrato nell'esempio seguente:

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

Per impostazione predefinita, se non viene impostato alcun nome applicazione, verrà utilizzato application. Per modificare il nome, è possibile aggiungere la seguente proprietà al file bootstrap.properties:

spring.application.name: myapp

NOTA: quando imposti la proprietà ${spring.application.name}, non anteporre al nome dell'app la parola riservata application- per evitare problemi nella risoluzione della property source corretta.

Le proprietà di bootstrap compaiono nell'endpoint /env come property source ad alta priorità, come mostrato nell'esempio seguente.

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

Una property source chiamata ```configService:/contiene la proprietàfoocon un valore dibar` ed è quella con priorità più alta.

NOTA: l'URL nel nome della property source è il repository git, non l'URL del config server.

=== Applicazione di esempio

Puoi trovare un'applicazione di esempio https://github.com/spring-cloud/spring-cloud-config/tree/master/spring-cloud-config-sample[qui]. È un'applicazione Spring Boot, quindi puoi eseguirla utilizzando i meccanismi consueti (ad esempio, mvn spring-boot:run). Quando viene eseguita, cerca il config server su http://localhost:8888 (un valore predefinito configurabile), quindi puoi eseguire anche il server per vedere come tutto funziona insieme.

L'esempio ha un caso di test in cui il config server viene avviato anche nella stessa JVM (con una porta diversa) e il test verifica che sia presente una proprietà di ambiente proveniente dal repository di configurazione git. Per cambiare la posizione del config server, puoi impostare spring.cloud.config.uri in bootstrap.yml (o nelle proprietà di sistema e in altri luoghi).

Il caso di test ha un metodo main() che esegue il server allo stesso modo (controlla i log per trovare la sua porta), quindi puoi eseguire l'intero sistema in un unico processo e sperimentarci (ad esempio, puoi eseguire il metodo main() nel tuo IDE). Il metodo main() usa target/config come directory di lavoro del repository git, quindi puoi apportare modifiche locali lì e vederle riflesse nell'app in esecuzione. L'esempio seguente mostra una sessione di sperimentazione con il caso di test:

$ 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

L'endpoint refresh segnala che la proprietà "sample" è cambiata.

== Building

:jdkversion: 1.7

=== Compilazione e test di base

Per compilare il sorgente dovrai installare JDK {jdkversion}.

Spring Cloud usa Maven per la maggior parte delle attività legate alla build, e dovresti riuscire a partire abbastanza rapidamente clonando il progetto che ti interessa e digitando

$ ./mvnw install

NOTA: puoi anche installare Maven (>=3.3.3) da solo ed eseguire il comando mvn al posto di ./mvnw negli esempi seguenti. Se lo fai, potresti anche dover aggiungere -P spring se le impostazioni Maven locali non contengono dichiarazioni di repository per gli artefatti spring pre-release.

NOTA: tieni presente che potresti dover aumentare la quantità di memoria disponibile per Maven impostando una variabile d'ambiente MAVEN_OPTS con un valore come -Xmx512m -XX:MaxPermSize=128m. Cerchiamo di coprire questo aspetto nella configurazione .mvn, quindi se scopri di doverlo fare per far riuscire una build, apri un ticket per far aggiungere le impostazioni al controllo sorgente.

Per suggerimenti su come compilare il progetto, guarda in .travis.yml se esiste. Dovrebbe esserci un comando "script" e forse "install". Controlla anche la sezione "services" per vedere se è necessario che alcuni servizi siano in esecuzione localmente (ad es. mongo o rabbit). Ignora le parti relative a git che potresti trovare in "before_install" poiché riguardano l'impostazione delle credenziali git e quelle le hai già.

I progetti che richiedono middleware generalmente includono un docker-compose.yml, quindi prendi in considerazione l'uso di https://docs.docker.com/compose/[Docker Compose] per eseguire i server middleware in container Docker. Vedi il README nel https://github.com/spring-cloud-samples/scripts[repository demo degli script] per istruzioni specifiche sui casi comuni di mongo, rabbit e redis.

NOTA: se tutto il resto fallisce, compila con il comando da .travis.yml (di solito ./mvnw install).

=== Documentazione

Il modulo spring-cloud-build ha un profilo "docs" e, se lo attivi, proverà a compilare le sorgenti asciidoc da src/main/asciidoc. Come parte di quel processo cercherà un README.adoc e lo elaborerà caricando tutti gli include, ma senza analizzarlo o renderizzarlo, semplicemente copiandolo in ${main.basedir} (il valore predefinito è ${basedir}, cioè la radice del progetto). Se ci sono modifiche al README, appariranno dopo una build Maven come file modificato nella posizione corretta. Basta committare e inviare la modifica.

=== Lavorare con il codice Se non hai un IDE preferito, ti consigliamo di usare https://www.springsource.com/developer/sts[Spring Tools Suite] o https://eclipse.org[Eclipse] quando lavori con il codice. Usiamo il plugin eclipse https://eclipse.org/m2e/[m2eclipse] per il supporto Maven. Anche altri IDE e strumenti dovrebbero funzionare senza problemi purché utilizzino Maven 3.3.3 o superiore.

==== Importare in Eclipse con m2eclipse Ti consigliamo il plugin eclipse https://eclipse.org/m2e/[m2eclipse] quando lavori con Eclipse. Se non hai già m2eclipse installato, è disponibile dall'"eclipse marketplace".

NOTA: le versioni precedenti di m2e non supportano Maven 3.3, quindi dopo aver importato i progetti in Eclipse dovrai anche dire a m2eclipse di usare il profilo giusto per i progetti. Se vedi molti errori diversi relativi ai POM nei progetti, verifica di avere un'installazione aggiornata. Se non puoi aggiornare m2e, aggiungi il profilo "spring" al tuo settings.xml. In alternativa puoi copiare le impostazioni del repository dal profilo "spring" del parent pom nel tuo settings.xml.

==== Importare in Eclipse senza m2eclipse Se preferisci non usare m2eclipse puoi generare i metadati del progetto eclipse usando il seguente comando:

[indent=0]

$ ./mvnw eclipse:eclipse

I progetti eclipse generati possono essere importati selezionando import existing projects dal menu file.

=== JCE

Se ricevi un'eccezione dovuta a "Illegal key size" e stai usando il JDK di Sun, devi installare i file Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy. Consulta i seguenti link per maggiori informazioni:

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]

Estrai i file JCE nella cartella JDK/jre/lib/security per qualunque versione di JRE/JDK x64/x86 utilizzi.

== Contribuire

:spring-cloud-build-branch: master

Spring Cloud è rilasciato sotto la licenza Apache 2.0 non restrittiva e segue un processo di sviluppo Github molto standard, usando il tracker Github per le issue e unendo le pull request in master. Se vuoi contribuire anche qualcosa di banale, non esitare, ma segui le linee guida qui sotto.

=== Firma il Contributor License Agreement Prima di accettare una patch o una pull request non banale, avremo bisogno che tu firmi il https://cla.pivotal.io/sign/spring[Contributor License Agreement]. Firmare l'accordo del contributore non concede a nessuno diritti di commit sul repository principale, ma significa che possiamo accettare i tuoi contributi e riceverai un credito come autore se lo facciamo. Ai contributori attivi potrebbe essere chiesto di unirsi al team centrale e di ricevere la possibilità di unire le pull request.

=== Codice di condotta Questo progetto aderisce al Contributor Covenant https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[codice di condotta]. Partecipando, ti viene chiesto di rispettare questo codice. Segnala comportamenti inaccettabili a [email protected].

=== Convenzioni di codice e pulizia Nessuna di queste cose è essenziale per una pull request, ma tutte aiutano. Possono anche essere aggiunte dopo la pull request originale ma prima di un merge.

Usa le convenzioni di formattazione del codice Spring Framework. Se usi Eclipse puoi importare le impostazioni del formatter usando il file eclipse-code-formatter.xml del progetto https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring Cloud Build]. Se usi IntelliJ, puoi usare https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter Plugin] per importare lo stesso file.
Assicurati che tutti i nuovi file .java abbiano un semplice commento di classe Javadoc con almeno un tag @author che ti identifichi e, preferibilmente, almeno un paragrafo su a cosa serve la classe.
Aggiungi l'intestazione di licenza ASF a tutti i nuovi file .java (copiala dai file esistenti nel progetto)
Aggiungiti come @author ai file .java che modifichi in modo sostanziale (più che modifiche estetiche).
Aggiungi qualche Javadoc e, se modifichi il namespace, alcuni elementi di documentazione XSD.
Anche un paio di test unitari aiuterebbero molto: qualcuno deve pur farli.
Se nessun altro sta usando il tuo branch, ti preghiamo di fare rebase sul master corrente (o su un altro branch di destinazione nel progetto principale).
Quando scrivi un messaggio di commit, segui https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[queste convenzioni]; se stai correggendo un'issue esistente, aggiungi Fixes gh-XXXX alla fine del messaggio di commit (dove XXXX è il numero dell'issue).

=== Checkstyle

Spring Cloud Build include una serie di regole checkstyle. Puoi trovarle nel modulo spring-cloud-build-tools. I file più notevoli del modulo sono:

.spring-cloud-build-tools/

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

<1> Regole Checkstyle predefinite <2> Configurazione dell'intestazione dei file <3> Regole di soppressione predefinite

==== Configurazione di Checkstyle

Le regole Checkstyle sono disabilitate per impostazione predefinita. Per aggiungere checkstyle al tuo progetto, definisci semplicemente le seguenti proprietà e plugin.

.pom.xml

true <1> true <2> true <3> <4> io.spring.javaformat spring-javaformat-maven-plugin <5> org.apache.maven.plugins maven-checkstyle-plugin

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

---- <1> Fa fallire la build in presenza di errori Checkstyle <2> Fa fallire la build in presenza di violazioni Checkstyle <3> Checkstyle analizza anche le sorgenti di test <4> Aggiungi il plugin Spring Java Format che riformatterà il tuo codice per superare la maggior parte delle regole di formattazione Checkstyle <5> Aggiungi il plugin checkstyle alle fasi di build e reporting

Se devi sopprimere alcune regole (ad es. la lunghezza delle righe deve essere maggiore), ti basta definire un file in `${project.root}/src/checkstyle/checkstyle-suppressions.xml` con le tue soppressioni. Esempio:.projectRoot/src/checkstyle/checkstyle-suppresions.xml

----

È consigliabile copiare ${spring-cloud-build.rootFolder}/.editorconfig e ${spring-cloud-build.rootFolder}/.springformat nel tuo progetto. In questo modo verranno applicate alcune regole di formattazione predefinite. Puoi farlo eseguendo questo script:```bash $ curl https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/.editorconfig -o .editorconfig $ touch .springformat

=== Configurazione IDE

==== Intellij IDEA

Per configurare Intellij dovresti importare le nostre convenzioni di codifica, i profili di ispezione e configurare il plugin checkstyle. I seguenti file si trovano nel progetto 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> Regole Checkstyle predefinite
<2> Configurazione dell'intestazione dei file
<3> Regole di soppressione predefinite
<4> Impostazioni predefinite del progetto per Intellij che applicano la maggior parte delle regole Checkstyle
<5> Convenzioni di stile del progetto per Intellij che applicano la maggior parte delle regole Checkstyle

.Stile del codice

image::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/{spring-cloud-build-branch}/docs/src/main/asciidoc/images/intellij-code-style.png[Stile del codice]

Vai su `File` -> `Settings` -> `Editor` -> `Code style`. Fai clic sull'icona accanto alla sezione `Scheme`. Quindi fai clic sull'opzione `Import Scheme` e scegli `Intellij IDEA code style XML`. Importa il file `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Spring_Boot_Java_Conventions.xml`.

.Profili di ispezione

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

Vai su `File` -> `Settings` -> `Editor` -> `Inspections`. Fai clic sull'icona accanto alla sezione `Profile`. Quindi fai clic su `Import Profile` e importa il file `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Project_Defaults.xml`.

.Checkstyle

Per far funzionare Intellij con Checkstyle, devi installare il plugin `Checkstyle`. È consigliabile installare anche `Assertions2Assertj` per convertire automaticamente le asserzioni JUnit

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

Vai su `File` -> `Settings` -> `Other settings` -> `Checkstyle`. Fai clic sull'icona `+` nella sezione `Configuration file`. Lì dovrai definire da dove devono essere prese le regole checkstyle. Nell'immagine sopra, abbiamo scelto le regole dal repository Spring Cloud Build clonato. Tuttavia, puoi puntare al repository GitHub di Spring Cloud Build (ad es. per `checkstyle.xml` : `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle.xml`). Dobbiamo fornire le seguenti variabili:

- `checkstyle.header.file` - punta al file `spring-cloud-build-tools/src/main/resources/checkstyle-header.txt` di Spring Cloud Build, sia nel tuo repository clonato che tramite l'URL `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/main/resources/checkstyle-header.txt`.
- `checkstyle.suppressions.file` - soppressioni predefinite. Punta al file `spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml` di Spring Cloud Build, sia nel tuo repository clonato che tramite l'URL `https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-build-tools/src/checkstyle/checkstyle-suppressions.xml`.
- `checkstyle.additional.suppressions.file` - questa variabile corrisponde alle soppressioni nel tuo progetto locale. Ad esempio, se stai lavorando su `spring-cloud-contract`. Quindi punta alla cartella `project-root/src/checkstyle/checkstyle-suppressions.xml`. Un esempio per `spring-cloud-contract` sarebbe: `/home/username/spring-cloud-contract/src/checkstyle/checkstyle-suppressions.xml`.

IMPORTANTE: ricordati di impostare `Scan Scope` su `All sources` dato che applichiamo le regole checkstyle sia alle sorgenti di produzione che di test.

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

Più Popolari