shoucheng3/spring-cloud__spring-cloud-config_cve-2020-5410_2-1-8-releaseServer di configurazione centralizzato per sistemi distribuiti con API HTTP, archiviazione basata su Git, crittografia/decrittografia delle proprietà e integrazione con Vault, JDBC e filesystem locali.
//// NON MODIFICARE QUESTO FILE. È STATO GENERATO. Le modifiche manuali a questo file andranno perse quando verrà rigenerato. 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, hai un punto centrale per gestire le proprietà esterne per le applicazioni in tutti gli ambienti.
I concetti sia lato client che lato server si mappano in modo identico alle astrazioni Spring Environment e PropertySource, quindi si adattano molto bene alle applicazioni Spring ma possono essere utilizzati con qualsiasi applicazione in esecuzione in qualsiasi linguaggio.
Quando un'applicazione si muove attraverso la pipeline di distribuzione dallo sviluppo al test e alla produzione, puoi gestire la configurazione tra questi ambienti ed essere certo che le applicazioni abbiano tutto ciò di cui hanno bisogno per funzionare quando vengono migrate.
L'implementazione predefinita del backend di archiviazione del server utilizza 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 con la configurazione Spring.
== Caratteristiche
=== Spring Cloud Config Server
Spring Cloud Config Server offre i seguenti vantaggi:
@EnableConfigServer=== Spring Cloud Config Client
Specificamente per le applicazioni Spring, Spring Cloud Config Client ti consente di:
Environment Spring con sorgenti di proprietà remote.@RefreshScope per gli @Bean Spring che vogliono essere reinizializzati quando la configurazione cambia./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 richiamare i metodi Lifecycle (stop() e sull').== Avvio rapido
Questo avvio rapido illustra l'utilizzo sia del server che del client di Spring Cloud Config Server.
Per prima cosa, avvia il server, come segue:
Il server è un'applicazione Spring Boot, quindi puoi eseguirlo dal tuo IDE se preferisci (la classe principale è ConfigServerApplication).
Successivamente prova un client, come segue:
La strategia predefinita per individuare le sorgenti di proprietà è clonare un repository git (all'indirizzo spring.cloud.config.server.git.uri) e utilizzarlo per inizializzare un mini SpringApplication.
L'Environment della mini-applicazione viene utilizzato per enumerare le sorgenti di proprietà e pubblicarle su un endpoint JSON.
Il servizio HTTP ha risorse nella seguente forma:
dove application viene iniettato come spring.config.name nel SpringApplication (quello che normalmente è application in una normale app Spring Boot), profile è un profilo attivo (o un elenco separato da virgole di proprietà) e label è un'etichetta git opzionale (il valore predefinito è master).
Spring Cloud Config Server recupera la configurazione per i client remoti da varie sorgenti. Il seguente esempio ottiene la configurazione da un repository git (che deve essere fornito), come mostrato nell'esempio seguente:
Altre sorgenti sono qualsiasi database compatibile con JDBC, Subversion, Hashicorp Vault, Credhub e filesystem locali.
=== Utilizzo lato client
Per utilizzare queste funzionalità in un'applicazione, puoi crearla 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ù conveniente per aggiungere la dipendenza è con uno starter Spring Boot org.springframework.cloud:spring-cloud-starter-config.
C'è anche un parent pom e BOM (spring-cloud-starter-parent) per utenti Maven e un file di proprietà di gestione delle versioni Spring IO per utenti Gradle e Spring CLI. Il seguente esempio mostra una tipica configurazione Maven:
<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 un'applicazione Spring Boot standard, 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 server config locale predefinito (se in esecuzione) sulla porta 8888.
Per modificare il comportamento di avvio, puoi cambiare la posizione del server config utilizzando bootstrap.properties (simile a application.properties ma per la fase di bootstrap di un contesto applicativo), come mostrato nell'esempio seguente:
Per impostazione predefinita, se non è impostato alcun nome applicazione, verrà utilizzato application. Per modificare il nome, la seguente proprietà può essere aggiunta al file bootstrap.properties:
NOTA: Quando si imposta la proprietà ${spring.application.name}, non anteporre al nome dell'app la parola riservata application- per evitare problemi nella risoluzione della corretta sorgente di proprietà.
Le proprietà di bootstrap vengono visualizzate nell'endpoint /env come una sorgente di proprietà ad alta priorità, come mostrato nell'esempio seguente.
Una sorgente di proprietà chiamata ```configService:/contiene la proprietàfoocon un valore dibar` ed è la priorità più alta.
NOTA: L'URL nel nome della sorgente di proprietà è il repository git, non l'URL del server config.
=== 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 usuali (ad esempio, mvn spring-boot:run).
Quando viene eseguita, cerca il server config su http://localhost:8888 (un valore predefinito configurabile), quindi puoi eseguire anche il server per vedere tutto funzionare insieme.
L'esempio ha un caso di test in cui il server config viene avviato anche nello stesso JVM (con una porta diversa), e il test asserisce che una
proprietà di ambiente dal repository di configurazione git sia presente.
Per cambiare la posizione del server config, 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 (guarda i log per la sua porta), in modo da poter eseguire l'intero sistema in un unico processo e sperimentare (ad esempio, puoi eseguire il metodo main() nel tuo IDE).
Il metodo main() utilizza target/config come directory di lavoro del repository git, quindi puoi apportare modifiche locali lì e vederle riflesse nell'app in esecuzione. Il seguente esempio mostra una sessione di sperimentazione con il caso di test:
L'endpoint di refresh segnala che la proprietà "sample" è cambiata.
== Build
:jdkversion: 1.7
=== Compilazione e test di base
Per compilare il sorgente dovrai installare JDK {jdkversion}.
Spring Cloud utilizza Maven per la maggior parte delle attività relative alla build, e dovresti essere in grado di iniziare abbastanza rapidamente clonando il progetto che ti interessa e digitando
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 tue impostazioni Maven locali non
contengono dichiarazioni di repository per gli artefatti di pre-rilascio Spring.
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 sì che la build
riesca, per favore apri un ticket per far aggiungere le impostazioni al
controllo del codice sorgente.
Per suggerimenti su come compilare il progetto, guarda in .travis.yml se
ce n'è uno. Dovrebbe esserci un comando "script" e forse "install". Guarda
anche la sezione "services" per vedere se alcuni servizi devono essere
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 le hai già.
I progetti che richiedono middleware generalmente includono un
docker-compose.yml, quindi considera l'utilizzo di
https://docs.docker.com/compose/[Docker Compose] per eseguire i server middleware
in contenitori Docker. Vedi il README nel
https://github.com/spring-cloud-samples/scripts[repository di script demo]
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 attivi
quello, cercherà di 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 non
analizzandolo né renderizzandolo, semplicemente copiandolo in ${main.basedir}
(predefinito a ${basedir}, cioè la radice del progetto). Se ci sono
cambiamenti nel README, appariranno dopo una build Maven come
un file modificato nella posizione corretta. Basta fare il commit e inviare la modifica.
=== Lavorare con il codice Se non hai una preferenza per un IDE, ti consigliamo di utilizzare 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. Altri IDE e strumenti dovrebbero funzionare anch'essi senza problemi purché utilizzino Maven 3.3.3 o superiore.
==== Importazione in Eclipse con m2eclipse Raccomandiamo il plugin eclipse https://eclipse.org/m2e/[m2eclipse] quando si lavora con eclipse. Se non hai già installato m2eclipse, è disponibile nell'"eclipse marketplace".
NOTA: Le versioni precedenti di m2e non supportano Maven 3.3, quindi una volta
importati i progetti in Eclipse dovrai anche dire a
m2eclipse di utilizzare il profilo giusto per i progetti. Se vedi
molti errori diversi relativi ai POM nei progetti, controlla
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 pom
padre nel tuo settings.xml.
==== Importazione in Eclipse senza m2eclipse Se preferisci non utilizzare m2eclipse, puoi generare i metadati del progetto eclipse usando il seguente comando:
$ ./mvnw eclipse:eclipse
I progetti eclipse generati possono essere importati selezionando import existing projects
dal menu file.
=== JCE
Se ottieni un'eccezione dovuta a "Illegal key size" e stai usando il JDK di Sun, devi installare i file del Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy. Vedi 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 la versione di JRE/JDK x64/x86 che usi.
== Contribuire
:spring-cloud-build-branch: master
Spring Cloud è pubblicato sotto la licenza non restrittiva Apache 2.0, e segue un processo di sviluppo Github molto standard, utilizzando il tracker Github per le issue e unendo le pull request in master. Se vuoi contribuire anche con qualcosa di banale, non esitare, ma segui le linee guida seguenti.
=== Firma il Contributor License Agreement Prima di accettare una patch o 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 d'autore se lo facciamo. Ai contributori attivi potrebbe essere chiesto di unirsi al team principale, e ottenere la capacità di unire le pull request.
=== Codice di condotta Questo progetto aderisce al codice di condotta del 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 aspettiamo che sostieni questo codice. Si prega di segnalare comportamenti inaccettabili a [email protected].
=== Convenzioni di codice e pulizia domestica Nessuna di queste è essenziale per una pull request, ma tutte aiuteranno. Possono anche essere aggiunte dopo la pull request originale ma prima di un merge.
eclipse-code-formatter.xml dal
https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[progetto
Spring Cloud Build]. Se usi IntelliJ, puoi usare il
https://plugins.jetbrains.com/plugin/6546[Plugin Eclipse Code Formatter]
per importare lo stesso file..java abbiano un semplice commento Javadoc di classe con almeno un
tag @author che ti identifichi, e preferibilmente almeno un paragrafo su cosa serve la classe..java (copia da file esistenti
nel progetto)@author nei file .java che modifichi in modo sostanziale (più
di modifiche estetiche).Fixes gh-XXXX alla fine del messaggio
di commit (dove XXXX è il numero dell'issue).=== Checkstyle
Spring Cloud Build viene fornito con un insieme di regole checkstyle. Puoi trovarle nel modulo spring-cloud-build-tools. I file più notevoli sotto il modulo sono:
<1> Regole Checkstyle predefinite <2> Impostazione dell'intestazione del file <3> Regole di soppressione predefinite
==== Configurazione Checkstyle
Le regole Checkstyle sono disabilitate per impostazione predefinita. Per aggiungere checkstyle al tuo progetto, definisci semplicemente le seguenti proprietà e plugin.
<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 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, è necessario importare le nostre convenzioni di codifica, i profili di ispezione e impostare 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> Impostazione intestazione 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[Code style]
Vai su `File` -> `Impostazioni` -> `Editor` -> `Stile del codice`. Fai clic sull'icona accanto alla sezione `Schema`. Quindi, fai clic sul valore `Importa schema` e seleziona l'opzione `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[Code style]
Vai su `File` -> `Impostazioni` -> `Editor` -> `Ispezioni`. Fai clic sull'icona accanto alla sezione `Profilo`. Quindi, fai clic su `Importa profilo` e importa il file `spring-cloud-build-tools/src/main/resources/intellij/Intellij_Project_Defaults.xml`.
.Checkstyle
Per far funzionare Intellij con Checkstyle, è necessario installare il plugin `Checkstyle`. Si consiglia di 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` -> `Impostazioni` -> `Altre impostazioni` -> `Checkstyle`. Fai clic sull'icona `+` nella sezione `File di configurazione`. Qui dovrai definire da dove prelevare le regole checkstyle. Nell'immagine sopra abbiamo selezionato le regole dal repository clonato di Spring Cloud Build. Tuttavia, puoi puntare al repository GitHub di Spring Cloud Build (ad esempio 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 repo 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 repo 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`, 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 `Ambito di scansione` su `Tutti i sorgenti` poiché applichiamo le regole checkstyle sia per i sorgenti di produzione che di test.
start()ApplicationContext