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. Vous trouverez ci-dessous 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

Sortir

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           8082/TCP,8025/TCP,8081/TCP   3m19s
service/artifactory-oss-postgresql            ClusterIP   10.96.95.36            5432/TCP                     3m19s
service/artifactory-oss-postgresql-headless   ClusterIP   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 demandes 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/ »

Vous pouvez vous connecter en utilisant le nom d'utilisateur par défaut « admin » et le mot de passe « mot de passe ». Lors de votre première connexion, Artifactory vous demandera de modifier le mot de passe par défaut. Assurez-vous de mettre à jour le mot de passe, définissez l'URL de base sur http://jfrog.artifactory.devops.myapp.com (le domaine configuré dans la ressource Artifactory Ingress) et ignorez toute autre étape de configuration initiale.

Nous pouvons créer les configurations initiales des référentiels pour pousser les dépendances et les binaires dans l'artefact.

Accédez à « Artifactory → Artefacts → Gérer les référentiels → Créer un référentiel » et créez les référentiels suivants :

• Local : ce référentiel gère les binaires de votre application. Par exemple « instantané de mon application » 
• Remote : ce référentiel stocke toutes les dépendances utilisées dans votre application, qui seront téléchargées à partir des référentiels centraux et stockées dans le référentiel. Par exemple « mon-app-central-snapshot » 
• Virtuel : ce référentiel virtuel fournit un point de terminaison commun qui regroupe les référentiels « Local » et « Distant ». Ce point de terminaison sera configuré dans votre application. «instantané-virtuel-de-mon-application»

J'utilise le référentiel maven pour maintenir le référentiel. Après la configuration, nous devons donner le référentiel local « my-app-snapshot »

Après la configuration, nous devons donner le référentiel local « my-app-central-snapshot »

Après la configuration, nous devons donner le référentiel local « my-app-virtual-snapshot »

Ajoutez les référentiels locaux et distants au référentiel virtuel et sélectionnez le référentiel local dans le « Dépôt de déploiement par défaut ».

Une fois tous les référentiels créés, vous pouvez les visualiser dans la section principale sous « Artifactory → Artefacts ». L'URL virtuelle http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/ sera utilisée pour votre application Maven.

Nous devons configurer les détails d'authentification dans le fichier de configuration des paramètres Maven « ~/.m2/settings.xml » pour permettre à votre application Maven de s'authentifier auprès d'Artifactory.

    
        
            my-app-virtual-snapshot
            admin
            Give your artifactory admin passoword
        
    

Remarque : l'utilisateur administrateur ne doit pas être utilisé pour l'accès à l'interface utilisateur et à Artifactory. Au lieu de cela, créez un utilisateur personnalisé avec les autorisations appropriées pour la lecture et l'écriture dans Artifactory.

Nous avons configuré le référentiel Maven et les balises de gestion de distribution dans le fichier XML POM de notre application Maven

    
        false
        my-app-virtual-snapshot
        my-app-virtual-snapshot
        http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/
        default
    



    
        my-app-virtual-snapshot
        my-app-virtual-snapshot
        http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/
        default
    

Nous pouvons déployer l'application maven avec la commande suivante

mvn clean deploy

Nous pouvons obtenir le résultat suivant de maven :

Référence Git Repo

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