Richten Sie JFrog Artifactory auf Kubernetes ein und verbinden Sie die Spring Boot-Anwendung

Dieses Dokument bietet Anleitungen zum Einrichten von JFrog Artifactory in einem Kubernetes-Cluster. Es dient als grundlegendes Tutorial für Entwickler zur Installation und Konfiguration von JFrog in einer Kubernetes-Umgebung, die auf einem lokalen Computer ausgeführt wird.

Richten Sie eine lokale Umgebung ein, um DevOps-Ressourcen aufzubauen

Ich verwende Docker-Container, um Arbeitsumgebungen für mehrere Anwendungen einzurichten (Setup-Umgebung). Dieser Ansatz gewährleistet vollständig isolierte und wartbare Umgebungen für die Anwendungsentwicklung, sodass wir diese Umgebungen einfach starten und beenden können. Unten finden Sie den Docker-Befehl zum Erstellen der Umgebung.

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

Der Container enthält Docker, Kubectl, Helm, Terraform, Kind, Git

Richten Sie Jenkins im Kubernetes-Cluster ein

Ich habe alle Terraform-Skripte erstellt, die im GitHub-Repository verfügbar sind. Sie können Jenkins herunterladen und auf einem Kubernetes-Cluster einrichten, der lokal in einem Docker-Container ausgeführt wird.

Klonen Sie das Repository auf Ihren lokalen Linux-Computer, um loszulegen.

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

Richten Sie den Kubernetes-Cluster in einem Docker-Container mit Kind ein und benennen Sie den Cluster „devops-jfrog-cluster-control-plane“. Dieser Cluster unterstützt Eingang und stellt die Ports 80 und 443 bereit, um den Zugriff auf Dienste zu ermöglichen von außerhalb des Clusters.

Cluster-Create-Terraform-Skript verfügbar im Ordner „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

Folgender Befehl überprüft den Cluster

kubectl cluster-info
kubectl get nodes -o wide

Nginx-Ingress-Controller auf Kubernetes-Cluster einrichten
Der NGINX Ingress Controller zur Verwaltung des externen Zugriffs auf Dienste in einem Kubernetes-Cluster. Es fungiert als Einstiegspunkt für Ihre Kubernetes-Anwendungen und leitet externen HTTP- und HTTPS-Verkehr an die entsprechenden Dienste innerhalb des Clusters weiter.

Mit dem folgenden Befehl wird der Ingress-Controller im Cluster installiert

Ingress-Erstellungsskript verfügbar im Ordner „ingress“

cd ingress
kubectl apply -f ingress-nginx.yaml

Folgender Befehl überprüft den Nginx-Ingress-Controller

kubectl get -n ingress-nginx pod

Ausgabe

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

JFrog Artifactory OSS einrichten (Open Source)

Fügen Sie das JFrog Artifactory OSS Community Helm-Repository hinzu: Zunächst müssen Sie das JFrog Artifactory OSS Community Helm-Repository zu Ihrem Helm-Client hinzufügen:

Hinweis: JFrog-Erstellungsskripte sind im Ordner „jfrog“ verfügbar

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

Der folgende Befehl kann verwendet werden, um die App-Version und Diagrammversion der im Cluster installierten Dienste zu überprüfen:

helm search repo  artifactory-oss

In diesem Beispiel installiere ich die Warenkorbversion „107.90.8“ und die App-Version „7.90.8“

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

Erstellen Sie eine Helm-Werte-YAML-Datei mit dem Namen helm-value.yaml, die zum Konfigurieren des JFrog Artifactory OSS-Dienstes verwendet wird. Diese Konfigurationsdatei wird von Helm verwendet, um den Dienst im Cluster zu installieren.

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

In der obigen Konfiguration habe ich folgende Punkte konfiguriert:

• Helm verwendet die Standard-PostgreSQL-Datenbank, in der ich das Datenbankkennwort angegeben habe.
• NGINX- und Ingress-Ressourcen sind deaktiviert.

Der folgende Helm-Befehl wird verwendet, um Artifactory im Cluster zu installieren. Es erstellt die erforderlichen Ressourcen im Cluster, einschließlich eines Namespace namens „artifactory-oss“, und installiert alle Ressourcen innerhalb dieses Namespace.

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

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

Wir können überprüfen, ob alle Ressourcen im Namespace „artifactory-oss“ installiert wurden. Die Benutzeroberfläche des Artifactory-Dienstes wird auf Port 8082 ausgeführt, während Artifactory selbst auf Port 8081 ausgeführt wird.

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

Wir müssen eine Ingress-Ressource erstellen, um Anfragen an den Artifactory-Dienst weiterzuleiten. Fügen Sie die folgende Konfiguration zur Datei ingress-resource.yaml hinzu.

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

Wir müssen Proxy-Body-Size=0 konfigurieren. Diese Einstellung weist Ingress an, beim Hochladen von Dateien auf Artifactory keine Begrenzung der Dateigröße festzulegen.

Führen Sie den folgenden Befehl aus, um den Ingress im Cluster anzuwenden

kubectl apply -f ingress-resource.yaml

Überprüfen Sie, ob die IP-Adresse eingestellt ist:

kubectl -n artifactory-oss get ingress

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

Fügen Sie unsere Domain am Ende der Datei /etc/hosts auf Ihrem lokalen Computer hinzu. Diese Konfiguration sollte sich nicht in unserer funktionierenden Linux-Box „test-jfrog-envornment-box“ befinden; Es sollte auf die Datei /etc/hosts Ihres persönlichen Computers angewendet werden.
(Sie benötigen Administratorzugriff):

127.0.0.1 jfrog.artifactory.devops.myapp.com

Wir können die künstliche Benutzeroberfläche im Browser „http://jfrog.artifactory.devops.myapp.com/“ öffnen

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

Das obige ist der detaillierte Inhalt vonRichten Sie JFrog Artifactory auf Kubernetes ein und verbinden Sie die Spring Boot-Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!