Configurer JFrog Artifactory sur Kubernetes et connecter l'application Spring Boot

Ce document fournit des conseils sur la configuration de JFrog Artifactory dans un cluster Kubernetes. Il sert de didacticiel de base permettant aux développeurs d'installer et de configurer JFrog sur un environnement Kubernetes exécuté sur une machine locale.

Configurer un environnement local pour créer des ressources DevOps

J'utilise des conteneurs Docker pour configurer des environnements de travail pour plusieurs applications (Setup Environment). Cette approche garantit des environnements entièrement isolés et maintenables pour le développement d'applications, nous permettant de démarrer et de terminer facilement ces environnements. Ci-dessous se trouve la commande Docker pour créer l'environnement.

docker run -it --name test-jfrog-envornment-box -v ${HOME}/root/ -v ${PWD}/work -w /work --net host developerhelperhub/kub-terr-work-env-box sh

Le conteneur contient Docker, Kubectl, Helm, Terraform, Kind, Git

Configurer Jenkins sur le cluster Kubernetes

J'ai créé tous les scripts Terraform, disponibles dans le référentiel GitHub. Vous pouvez télécharger et configurer Jenkins sur un cluster Kubernetes, qui s'exécute localement dans un conteneur Docker.

Clonez le référentiel sur votre machine Linux locale pour commencer.

git clone https://github.com/developerhelperhub/kuberentes-help.git
cd kuberentes-help/kubenretes/tutorials/sections/0009/

Configurez le cluster Kubernetes dans un conteneur Docker à l'aide de Kind, en nommant le cluster « devops-jfrog-cluster-control-plane ». Ce cluster prend en charge l'entrée et expose les ports 80 et 443 pour autoriser l'accès aux services de l'extérieur du cluster.

Cluster crée un script Terraform disponible dans le dossier Kind

cd kind
terraform init #Install the required providers to set up the necessary resources.
terraform plan #Verify the resources that will be installed on the system.
terraform apply #Install resources on the system

La commande suivante vérifie le cluster

kubectl cluster-info
kubectl get nodes -o wide

Configurer le contrôleur d'entrée Nginx sur le cluster Kubernetes
Le contrôleur d'entrée NGINX pour gérer l'accès externe aux services dans un cluster Kubernetes. Il agit comme un point d'entrée pour vos applications Kubernetes, acheminant le trafic HTTP et HTTPS externe vers les services appropriés au sein du cluster.

La commande suivante installe le contrôleur d'entrée sur le cluster

Script de création Ingress disponible dans le dossier « ingress »

cd ingress
kubectl apply -f ingress-nginx.yaml

La commande suivante vérifie le contrôleur d'entrée nginx

kubectl get -n ingress-nginx pod

Sortie

NAME                                       READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-5mt2k       0/1     Completed   0          53s
ingress-nginx-admission-patch-w2rlk        0/1     Completed   0          53s
ingress-nginx-controller-d45d995d4-gl65h   1/1     Running     0          53s

Configurer JFrog Artifactory OSS (Open Source)

Ajoutez le référentiel Helm de la communauté JFrog Artifactory OSS : pour commencer, vous devez ajouter le référentiel Helm de la communauté JFrog Artifactory OSS à votre client Helm :

Remarque : JFrog crée des scripts disponibles dans le dossier « jfrog »

helm repo add jfrog https://charts.jfrog.io
helm repo update

La commande suivante peut être utilisée pour vérifier la version de l'application et la version du graphique des services installés dans le cluster :

helm search repo  artifactory-oss

Dans cet exemple, j'installe la version du panier « 107.90.8 » et la version de l'application est « 7.90.8 »

NAME                         CHART VERSION        APP VERSION        DESCRIPTION
jfrog/artifactory-oss        107.90.8             7.90.8             JFrog Artifactory OSS

Créez un fichier YAML de valeurs Helm nommé helm-value.yaml, qui sera utilisé pour configurer le service JFrog Artifactory OSS. Ce fichier de configuration sera utilisé par Helm pour installer le service dans le cluster.

artifactory:
    postgresql:
    postgresqlPassword: postgres_password
    nginx:
    enabled: false
    ingress:
    enabled: false

Dans la configuration ci-dessus, j'ai configuré les points suivants :

• Helm utilise la base de données PostgreSQL par défaut, où j'ai spécifié le mot de passe de la base de données.
• Les ressources NGINX et Ingress sont désactivées.

La commande Helm suivante est utilisée pour installer Artifactory dans le cluster. Il crée les ressources nécessaires dans le cluster, y compris un espace de noms appelé « artifactory-oss », et installe toutes les ressources dans cet espace de noms.

helm install artifactory-oss -f helm-value.yaml jfrog/artifactory-oss --namespace artifactory-oss --create-namespace

Valeurs du graphique Helm : https://github.com/jfrog/charts/blob/master/stable/artifactory-oss/values.yaml

Nous pouvons vérifier que toutes les ressources ont été installées dans l'espace de noms "artifactory-oss". L'interface utilisateur du service Artifactory s'exécute sur le port 8082, tandis qu'Artifactory lui-même fonctionne sur le port 8081.

kubectl get -n artifactory-oss all

NAME                               READY   STATUS    RESTARTS   AGE
pod/artifactory-oss-0              0/7     Running   0          3m19s
pod/artifactory-oss-postgresql-0   1/1     Running   0          3m19s

NAME                                          TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
service/artifactory-oss                       ClusterIP   10.96.170.63   <none>        8082/TCP,8025/TCP,8081/TCP   3m19s
service/artifactory-oss-postgresql            ClusterIP   10.96.95.36    <none>        5432/TCP                     3m19s
service/artifactory-oss-postgresql-headless   ClusterIP   None           <none>        5432/TCP                     3m19s

NAME                                          READY   AGE
statefulset.apps/artifactory-oss              0/1     3m19s
statefulset.apps/artifactory-oss-postgresql   1/1     3m19s

Nous devons créer une ressource Ingress pour acheminer les requêtes vers le service Artifactory. Ajoutez la configuration suivante au fichier ingress-resource.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
    name: jfrog-ingress
    namespace: artifactory-oss
    annotations:
    nginx.ingress.kubernetes.io/proxy-body-size: "0"
spec:
    ingressClassName: nginx
    rules:
    - host: jfrog.artifactory.devops.myapp.com
        http:
        paths:
            - path: /
            pathType: ImplementationSpecific
            backend:
                service:
                name: artifactory-oss
                port:
                    number: 8082

Nous devons configurer proxy-body-size=0. Ce paramètre indique à Ingress de ne pas imposer de limite sur la taille du fichier lors du téléchargement de fichiers vers Artifactory.

Exécutez la commande suivante pour appliquer l'entrée dans le cluster

kubectl apply -f ingress-resource.yaml

Vérifiez que l'adresse IP est définie :

kubectl -n artifactory-oss get ingress

NAME            CLASS   HOSTS                                ADDRESS     PORTS   AGE
jfrog-ingress   nginx   jfrog.artifactory.devops.myapp.com   localhost   80      2m53s

Ajoutez notre domaine au bas du fichier /etc/hosts sur votre machine locale. Cette configuration ne doit pas se trouver dans notre boîte Linux de travail « test-jfrog-envornment-box » ; il doit être appliqué au fichier /etc/hosts de votre machine personnelle.
(vous aurez besoin d'un accès administrateur) :

127.0.0.1 jfrog.artifactory.devops.myapp.com

Nous pouvons ouvrir l'interface utilisateur de l'artefact dans le navigateur « http://jfrog.artifactory.devops.myapp.com/ »

You can log in using the default username "admin" and password "password." Upon your first login, Artifactory will prompt you to change the default password. Be sure to update the password, set the base URL to http://jfrog.artifactory.devops.myapp.com (the domain configured in the Artifactory Ingress resource), and skip any other initial configuration steps.

We can create the initial repositories configurations to push the dependencies and binary in the artifactory.

Navigate to “Artifactory → Artifacts → Manage Repositories → Create Repository” and create the following repositories:

• Local: This repository manages your application binaries. For example “my-app-snapshot”
• Remote: This repository stores all dependencies used in your application, which will be downloaded from central repositories and stored in repository. For example “my-app-central-snapshot”
• Virtual: This virtual repository provides a common endpoint that aggregates the “Local” and “Remote” repositories. This endpoint will be configured in your application. “my-app-virtual-snapshot”

I am using maven repository to maintain the repository. Following configuration we have to give “my-app-snapshot” local repository

Following configuration we have to give “my-app-central-snapshot” local repository

Following configuration we have to give “my-app-virtual-snapshot” local repository

Add the local and remote repositories to the virtual repository and select the local repository in the “Default Deployment Repository”.

Once all the repositories are created, you can view them in the main section under “Artifactory → Artifacts.” The virtual URL http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/ will be used for your Maven application.

We need to configure the authentication details in the Maven settings configuration file “~/.m2/settings.xml” to enable your Maven application to authenticate with Artifactory.

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd">
    <servers>
        <server>
            <id>my-app-virtual-snapshot</id>
            <username>admin</username>
            <password>Give your artifactory admin passoword</password>
        </server>
    </servers>
</settings>

Note: The admin user should not be used for UI and Artifactory access. Instead, create a custom user with appropriate permissions for reading and writing in Artifactory.

We have configure the maven repository and distribution management tags inside our maven application POM XML file

<distributionManagement>
    <repository>
        <uniqueVersion>false</uniqueVersion>
        <id>my-app-virtual-snapshot</id>
        <name>my-app-virtual-snapshot</name>
        <url>http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/</url>
        <layout>default</layout>
    </repository>
</distributionManagement>

<repositories>
    <repository>
        <id>my-app-virtual-snapshot</id>
        <name>my-app-virtual-snapshot</name>
        <url>http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/</url>
        <layout>default</layout>
    </repository>
</repositories>

The we can deploy the maven application with following command

mvn clean deploy

We can the following output of maven :

Refernece Git Repo

• https://github.com/developerhelperhub/spring-boot-jfrog-artifact-app
• https://github.com/developerhelperhub/kuberentes-help/tree/main/kubenretes/tutorials/sections/0009

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!