Spinnaker rencontre Minikube : partie 2

introduction

Dans l’article précédent, nous avons installé Spinnaker sur un cluster Minikube fonctionnant sous Windows 10. Dans cet article, nous ajouterons GitHub en tant que fournisseur de données pour un pipeline Spinnaker afin de déployer en continu un microservice Spring Boot dockerisé sur le cluster Minikube. Le pipeline sera déclenché à l’aide d’une tâche Cron et peut être modélisé de sorte que tous ses micro-services soient automatiquement déployés pour disposer d’un environnement de développement local entièrement à jour à tout moment.

Conditions

Une compréhension de Spring Boot, Github et Docker Hub est présumée. Cependant, des instructions de secours seront données pour ceux qui souhaitent suivre une piste plus légère qui extrait l’image Docker du registre de l’auteur. Cependant, certaines choses comme une liaison d’artefact appropriée peuvent ne pas fonctionner comme prévu si le guide complet n’est pas suivi.

Spring Boot : l’objet d’affection

Cette étape est facultative pour ceux sur la voie légère car le code est disponible sur jrb-s2c-github/spinnaker_tryout (branche google-jib-maven-plugin) et l’image docker résultante peut être extraite directement du registre DockerHub.

La première étape consiste à créer un microservice Spring Boot qui doit être archivé dans un référentiel Github.

Le contrôleur utilisé pour cet affichage est le suivant :

package s2c.hello_svc;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class HelloController {

    @RequestMapping("https://dzone.com/")
    public String index() {
        return "Greetings from " + name;
    }

    private String name = "Minikube";

}

Avec le Maven pom.xml :

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>hello-svc</artifactId>
    <groupId>s2c.spinnaker.tryout</groupId>
    <version>1.0.18</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
    </parent>

    <name>S2C Spinnaker Tryout :: Hello Service</name>

    <description>
        Spring Boot application with a single REST endpoint using JIB.
    </description>

    <properties>
        <jkube.version>1.0.2</jkube.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <jkube.build.strategy>jib</jkube.build.strategy>
    </properties>

    <distributionManagement>
        <snapshotRepository>
            <id>sonatype-nexus-snapshots</id>
            <name>Sonatype Nexus Snapshots</name>
            <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
        </snapshotRepository>
        <repository>
            <id>sonatype-nexus-staging</id>
            <name>Nexus Release Repository</name>
            <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
        </repository>
    </distributionManagement>

    <dependencies>

        <!-- Boot generator  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jolokia</groupId>
            <artifactId>jolokia-core</artifactId>
        </dependency>
        <!-- API, java.xml.bind module -->
        <dependency>
            <groupId>jakarta.xml.bind</groupId>
            <artifactId>jakarta.xml.bind-api</artifactId>
            <version>2.3.2</version>
        </dependency>

        <!-- Runtime, com.sun.xml.bind module -->
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.3.2</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>

            <plugin>
                <groupId>com.google.cloud.tools</groupId>
                <artifactId>jib-maven-plugin</artifactId>
                <version>3.1.4</version>
                <configuration>
                    <from>
                        <image>openjdk:11-jdk-slim</image>
                    </from>
                    <to>
                        <image>docker.io/rbuhrmann/hello-svc</image>
                    </to>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>

L’authentification pour le hub Docker doit être ajoutée à la section serveur du fichier settings.xml de Maven si l’on souhaite pousser vers le hub Docker à partir de la ligne de commande :

<servers>
  <server>
    <id>registry-1.docker.io</id>
    <username>rbuhrmann</username>
    <password>${PASSWORD}</password>
  </server>
</servers>

Le jib-maven-plugin de Google peut ensuite être utilisé pour pousser vers le hub Docker à l’aide de Maven :

mvn jib: build

Github : le créateur

Cette rubrique est facultative. La commande maven ci-dessus peut être utilisée pour une intégration continue au registre Docker.

Enregistrez votre projet Spring Boot sur le compte Github. On peut également bifurquer le projet de l’auteur à partir de https://github.com/jrb-s2c-github/spinnaker_tryout, en utilisant la branche « google-jib-maven-plugin ».

L’intégration continue est à mettre en œuvre à l’aide d’une action Github :

# This workflow will build a Java project with Maven
# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven

name: Java CI with Maven

on:
  push:
    branches: [ google-jib-maven-plugin, main ]
  pull_request:
    branches: [ google-jib-maven-plugin, main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Set up JDK 11
      uses: actions/setup-java@v2
      with:
        java-version: '11'
        distribution: 'adopt'
    - name: Build with Maven
      run: mvn -B clean compile jib:build -Djib.to.image=rbuhrmann/hello-svc:$GITHUB_SHA -Djib.to.auth.username=${{ secrets.DOCKER_USER }} -Djib.to.auth.password=${{ secrets.DOCKER_PWD }} --file hello_svc/pom.xml

Le dernier identifiant de validation GIT est utilisé comme balise pour l’image Docker. De cette façon, on peut toujours tracer quel commit a été poussé dans un cluster Kubernetes. L’auteur est d’avis que l’on devrait être capable de traiter chaque build comme une release candidate.
Les informations d’identification Docker sont ajoutées à partir du magasin secret GitHub.

Il est maintenant temps de configurer Github en tant que fournisseur de données pour Spinnaker.

Github en tant que fournisseur pour Spinnaker

Cette étape est facultative. Le fichier manifeste peut également être copié dans l’interface utilisateur Spinnaker au lieu de le retirer de Github. Voir plus bas pour en savoir plus à ce sujet.

Spinnaker récupérera le fichier manifeste Kubernetes à partir de Github. En tant que tel, le Github doit être configuré en tant que fournisseur d’artefacts pour Github :

hal config artifact github account add jrb-s2c-github --token $TOKEN

Le jeton Github peut être créé ici et doit avoir la portée du dépôt.

Une fois le compte Github enregistré, Github doit être activé :

hal config artifact github enable

Il est temps de ‘hal deploy apply’ :

Étant donné que Spinnaker extraira l’artefact de déploiement de DockerHub, il nécessite des instructions d’un fichier manifeste Kubernetes sur la façon de procéder.

Donner un moteur à Spinnaker

Créez le déploiement Kubernetes et les descriptions de service pour votre projet Spring Boot :

kubectl create deployment hello-svc --image  rbuhrmann/hello-svc -o yaml --dry-run=true > deployment.yaml

kubectl create service nodeport hello-svc  --tcp 9090:8080 -o yaml --dry-run=true> service.yaml

Le microservice sera ouvert pour un accès extérieur en tant que NodePort.

Combinez les deux fichiers en un seul :

---
apiVersion: v1
kind: List
items:
  - apiVersion: v1
    kind: Service
    metadata:
      creationTimestamp: null
      labels:
        app: hello-svc
      name: hello-svc
    spec:
      ports:
        - name: 9090-8080
          port: 9090
          protocol: TCP
          targetPort: 8080
      selector:
        app: hello-svc
      type: NodePort
    status:
      loadBalancer: {}
  - apiVersion: apps/v1
    kind: Deployment
    metadata:
      creationTimestamp: null
      labels:
        app: hello-svc
      name: hello-svc
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: hello-svc
      strategy: { }
      template:
        metadata:
          creationTimestamp: null
          labels:
            app: hello-svc
        spec:
          containers:
            - image: rbuhrmann/hello-svc
              name: hello-svc
              resources: { }
    status: { }

Ce fichier peut être validé dans GitHub pour que Spinnaker soit déployé à partir de celui-ci ou il peut être copié directement dans votre premier pipeline Spinnaker. Dans tous les cas, il servira de moteur au premier pipeline de déploiement.

Le premier pipeline

Créez une nouvelle application Spinnaker comme décrit dans l’article précédent, puis cliquez sur « Pipeline » dans la navigation de gauche :

Cliquez sur « configurer un nouveau pipeline » :

Donnez un nom au pipeline et cliquez sur Créer :

Le déclencheur

L’éditeur de pipeline s’ouvrira. Cliquez sur « Ajouter un déclencheur » :

Sélectionnez Cron comme type de déclencheur :

Configurez la tâche Cron pour déclencher le pipeline toutes les deux minutes :

Le premier stade

Cette étape est facultative.

Ajoutez une étape de type « Evaluate Expression » et appelez-la « Evaluate Variables » :

Définissez le jeton d’autorisation Github sur une variable nommée « github_token » à l’aide de Spring Expression Language. Ce n’est pas obligatoire mais augmente le Github limite de débit donc on peut utiliser ce pipeline comme modèle avoir toujours le dernier ensemble de micro-services en cours d’exécution sur son environnement de développement local.

Spinnaker est maintenant prêt à récupérer la balise de la dernière image déployée dans le registre Docker.

La deuxième étape