Netflix Archaius avec diverses configurations de base de données

1. Vue d’ensemble

Netflix Archaius propose des bibliothèques et des fonctionnalités pour la connexion à de nombreuses sources de données.

Dans ce tutoriel, nous allons apprendre à obtenir des configurations: **
Utilisation de l’API JDBC pour se connecter à une base de données
À partir des configurations stockées dans une instance DynamoDB
En configurant Zookeeper en tant que configuration distribuée dynamique

Pour l’introduction à Netflix Archaius, veuillez regarder cet article .

2. Utilisation de Netflix Archaius avec une connexion JDBC

Comme nous l’avons expliqué dans le didacticiel d’introduction, chaque fois que nous voulons que Archaius gère les configurations, nous devons créer un bean AbstractConfiguration d’Apache.

Le bean sera automatiquement capturé par Spring Cloud Bridge et ajouté à la pile de configuration composite d’Archaius.

2.1. Les dépendances

Toutes les fonctionnalités requises pour se connecter à une base de données à l’aide de JDBC sont incluses dans la bibliothèque principale. Nous n’avons donc pas besoin de dépendances supplémentaires à part celles mentionnées dans le didacticiel d’introduction:

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-archaius</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix</artifactId>
            <version>2.0.1.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Nous pouvons vérifier que Maven Central utilise la dernière version de la bibliothèque starter .

2.2. Comment créer le bean de configuration

Dans ce cas, nous devrons créer le bean AbstractConfiguration en utilisant une instance JDBCConfigurationSource . **

Pour indiquer comment obtenir les valeurs de la base de données JDBC, nous devrons spécifier:

un objet javax.sql.Datasource
une chaîne de requête SQL qui va récupérer au moins deux colonnes avec le

Clés des configurations et valeurs correspondantes ** deux colonnes indiquant les propriétés clés et valeurs, respectivement

Continuons puis créons ce haricot:

@Autowired
DataSource dataSource;

@Bean
public AbstractConfiguration addApplicationPropertiesSource() {
    PolledConfigurationSource source =
      new JDBCConfigurationSource(dataSource,
        "select distinct key, value from properties",
        "key",
        "value");
    return new DynamicConfiguration(source, new FixedDelayPollingScheduler());
}

2.3. L’essayer

Pour rester simple et conserver un exemple opérationnel, nous allons configurer une instance de base de données H2 en mémoire avec certaines données initiales.

Pour cela, nous allons d’abord ajouter les dépendances nécessaires:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>2.0.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.197</version>
    <scope>runtime</scope>
</dependency>

Remarque: nous pouvons vérifier les dernières versions de https://search.maven.org/search? Q = g: com.h2database% 20a: h2[h2] et de https://search.maven.org/search ? q = a: bibliothèques Spring-Boot-Starter-Data-JPA% 20g: org.springframework.boot[Spring-Boot-Starter-Data-JPA] dans Maven Central.

Ensuite, nous allons déclarer l’entité JPA qui contiendra nos propriétés:

@Entity
public class Properties {
    @Id
    private String key;
    private String value;
}

Et nous allons inclure un fichier data.sql dans nos ressources pour renseigner la base de données en mémoire avec certaines valeurs initiales:

insert into properties
values('baeldung.archaius.properties.one', 'one FROM:jdbc__source');

Enfin, pour vérifier la valeur de la propriété à tout moment, nous pouvons créer un noeud final qui récupère les valeurs gérées par Archaius:

@RestController
public class ConfigPropertiesController {

    private DynamicStringProperty propertyOneWithDynamic = DynamicPropertyFactory
      .getInstance()
      .getStringProperty("baeldung.archaius.properties.one", "not found!");

    @GetMapping("/properties-from-dynamic")
    public Map<String, String> getPropertiesFromDynamic() {
        Map<String, String> properties = new HashMap<>();
        properties.put(propertyOneWithDynamic.getName(), propertyOneWithDynamic.get());
        return properties;
    }
}

Si les données changent à tout moment, Archaius les détectera au moment de l’exécution et commencera à récupérer les nouvelles valeurs.

Ce critère peut également être utilisé dans les exemples suivants.

3. Comment créer une source de configuration à l’aide d’une instance de DynamoDB

Comme nous l’avons fait dans la section précédente, nous allons créer un projet entièrement fonctionnel pour analyser correctement la gestion des propriétés par Archaius à l’aide d’une instance DynamoDB comme source de configurations.

3.1. Les dépendances

Ajoutons les bibliothèques suivantes à notre fichier pom.xml :

<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-dynamodb</artifactId>
    <version>1.11.414</version>
</dependency>
<dependency>
    <groupId>com.github.derjust</groupId>
    <artifactId>spring-data-dynamodb</artifactId>
    <version>5.0.3</version>
</dependency>
<dependency>
    <groupId>com.netflix.archaius</groupId>
    <artifactId>archaius-aws</artifactId>
    <version>0.7.6</version>
</dependency>

Nous pouvons vérifier Maven Central pour les dernières versions de dépendances, mais pour la version archaius-aws , nous suggérons de nous en tenir à la version supportée par https://github.com/spring-cloud/spring-cloud-netflix/blob/master/spring -cloud-netflix-dependencies/pom.xml[la bibliothèque Spring Cloud Netflix].

La dépendance aws-java-sdk-dynamodb nous permettra de configurer le client DynamoDB pour se connecter à la base de données.

Avec la bibliothèque spring-data-dynamodb , nous allons configurer le référentiel DynamoDB.

Enfin, nous allons utiliser la bibliothèque archaius-aws pour créer la AbstractConfiguration .

3.2. Utilisation de DynamoDB en tant que source de configuration

Cette fois, le _AbstractConfiguration sera créé à l’aide d’un objet DynamoDbConfigurationSource_ :

@Autowired
AmazonDynamoDB amazonDynamoDb;

@Bean
public AbstractConfiguration addApplicationPropertiesSource() {
    PolledConfigurationSource source = new DynamoDbConfigurationSource(amazonDynamoDb);
    return new DynamicConfiguration(
      source, new FixedDelayPollingScheduler());
}

Par défaut, Archaius recherche une table appelée "archaiusProperties", contenant une "clé" et des attributs "value" dans la base de données Dynamo à utiliser comme source.

Si nous voulons remplacer ces valeurs, nous devrons déclarer les propriétés système suivantes:

com.netflix.config.dynamo.tableName
com.netflix.config.dynamo.keyAttributeName
com.netflix.config.dynamo.valueAttributeName

3.3. Création d’un exemple entièrement fonctionnel

Comme nous l’avons fait à l’adresse this guide DynamoDB , nous allons commencer par installer une instance DynamoDB locale pour tester facilement la fonctionnalité.

Nous allons également suivre les instructions du guide pour créer l’instance AmazonDynamoDB que nous avons précédemment «câblée automatiquement».

Et pour renseigner la base de données avec certaines données initiales, nous allons d’abord créer une entité DynamoDBTable pour mapper les données:

@DynamoDBTable(tableName = "archaiusProperties")
public class ArchaiusProperties {

    @DynamoDBHashKey
    @DynamoDBAttribute
    private String key;

    @DynamoDBAttribute
    private String value;

   //...getters and setters...
}

Ensuite, nous allons créer un CrudRepository pour cette entité:

public interface ArchaiusPropertiesRepository extends CrudRepository<ArchaiusProperties, String> {}

Enfin, nous utiliserons le référentiel et l’instance AmazonDynamoDB pour créer la table et insérer les données par la suite:

@Autowired
private ArchaiusPropertiesRepository repository;

@Autowired
AmazonDynamoDB amazonDynamoDb;

private void initDatabase() {
    DynamoDBMapper mapper = new DynamoDBMapper(amazonDynamoDb);
    CreateTableRequest tableRequest = mapper
      .generateCreateTableRequest(ArchaiusProperties.class);
    tableRequest.setProvisionedThroughput(new ProvisionedThroughput(1L, 1L));
    TableUtils.createTableIfNotExists(amazonDynamoDb, tableRequest);

    ArchaiusProperties property = new ArchaiusProperties("baeldung.archaius.properties.one", "one FROM:dynamoDB");
    repository.save(property);
}

Nous pouvons appeler cette méthode juste avant de créer le DynamoDbConfigurationSource .

Nous sommes tous prêts à exécuter l’application.

4. Comment configurer une configuration distribuée de Zookeeper dynamique

Comme nous l’avons déjà vu, on plus d’un article introductif sur Zookeeper , l’un des avantages de cet outil est la possibilité de l’utiliser comme magasin de configuration distribuée. **

Si nous le combinons avec Archaius, nous obtenons une solution flexible et évolutive pour la gestion de la configuration.

4.1. Les dépendances

Suivez les instructions http://cloud.spring.io/spring-cloud-zookeeper/single/spring-cloud-zookeeper.html#spring-cloud-zookeeper-install dans les instructions officielles de Spring Cloud]pour configurer la version la plus stable Zookeeper d’Apache.

La seule différence est que nous n’avons besoin que d’une partie des fonctionnalités fournies par Zookeeper. Nous pouvons donc utiliser la dépendance spring-cloud-starter-zookeeper-config à la place de celle utilisée dans le guide officiel:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-config</artifactId>
    <version>2.0.0.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.13</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Encore une fois, nous pouvons vérifier les dernières versions de spring-cloud-starter-zookeeper-config et zookeeper dépendances dans Maven Central.

Assurez-vous d’éviter les versions bêta de zookeeper .

4.2. Configuration automatique de Spring Cloud

Comme expliqué dans la documentation officielle, inclure la dépendance spring-cloud-starter-zookeeper-config suffit pour configurer les sources de la propriété Zookeeper. **

Par défaut, une seule source est configurée automatiquement et recherche les propriétés sous le nœud config/application Zookeeper. Ce nœud est donc utilisé comme source de configuration partagée entre différentes applications.

De plus, si nous spécifions un nom d’application à l’aide de la propriété spring.application.name , une autre source est configurée automatiquement, cette fois en recherchant les propriétés dans le noeud config/<nom app> __.

Chaque nom de noeud sous ces noeuds parents indiquera une clé de propriété et leurs données seront la valeur de la propriété.

Heureusement pour nous, puisque Spring Cloud ajoute ces sources de propriétés au contexte, Archaius les gère automatiquement. Il n’est pas nécessaire de créer une AbstractConfiguration par programme.

4.3. Préparation des données initiales

Dans ce cas, nous aurons également besoin d’un serveur Zookeeper local pour stocker les configurations en tant que nœuds. Nous pouvons suivre this Apache’s Guide pour configurer un serveur autonome fonctionnant sur le port 2181.

Pour vous connecter au service Zookeeper et créer des données initiales, nous utiliserons le client Apache :

@Component
public class ZookeeperConfigsInitializer {

    @Autowired
    CuratorFramework client;

    @EventListener
    public void appReady(ApplicationReadyEvent event) throws Exception {
        createBaseNodes();
        if (client.checkExists().forPath("/config/application/baeldung.archaius.properties.one") == null) {
            client.create()
              .forPath("/config/application/baeldung.archaius.properties.one",
              "one FROM:zookeeper".getBytes());
        } else {
            client.setData()
              .forPath("/config/application/baeldung.archaius.properties.one",
              "one FROM:zookeeper".getBytes());
        }
    }

    private void createBaseNodes() throws Exception {
        if (client.checkExists().forPath("/config") == null) {
            client.create().forPath("/config");
        }
        if (client.checkExists().forPath("/config/application") == null) {
            client.create().forPath("/config/application");
        }
    }
}

Nous pouvons consulter les journaux pour voir les sources des propriétés afin de vérifier que Netflix Archaius a actualisé les propriétés une fois qu’elles ont été modifiées.

5. Conclusion

Dans cet article, nous avons appris comment configurer des sources de configuration avancées à l’aide de Netflix Archaius. Nous devons prendre en compte le fait qu’il prend également en charge d’autres sources, telles que Etcd, Typesafe, les fichiers AWS S3 et JClouds.

Comme toujours, nous pouvons consulter tous les exemples dans notre rapport Github .

TOC