Este documento fornece orientação sobre como configurar o JFrog Artifactory em um cluster Kubernetes. Ele serve como um tutorial básico para desenvolvedores instalarem e configurarem o JFrog em um ambiente Kubernetes executado em uma máquina local.

Configure o ambiente local para criar recursos DevOps

Eu uso contêineres Docker para configurar ambientes de trabalho para vários aplicativos (ambiente de configuração). Essa abordagem garante ambientes totalmente isolados e de fácil manutenção para o desenvolvimento de aplicativos, permitindo-nos iniciar e encerrar facilmente esses ambientes. Abaixo está o comando Docker para criar o ambiente.

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

O contêiner contém Docker, Kubectl, Helm, Terraform, Kind, Git

Configurar Jenkins no cluster Kubernetes

Eu criei todos os scripts do Terraform, que estão disponíveis no repositório GitHub. Você pode baixar e configurar o Jenkins em um cluster Kubernetes, que é executado localmente em um contêiner Docker.

Clone o repositório em sua máquina Linux local para começar.

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

Configure o cluster Kubernetes em um contêiner Docker usando Kind, nomeando o cluster “devops-jfrog-cluster-control-plane” Este cluster suporta entrada e expõe as portas 80 e 443 para permitir acesso aos serviços de fora do cluster.

Cluster create terraform script disponível na pasta 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

Seguinte comando, verifique o cluster

kubectl cluster-info
kubectl get nodes -o wide

Configure o controlador de entrada Nginx no cluster Kubernetes
O controlador de entrada NGINX para gerenciar o acesso externo aos serviços em um cluster Kubernetes. Ele atua como um ponto de entrada para seus aplicativos Kubernetes, roteando o tráfego HTTP e HTTPS externo para os serviços apropriados dentro do cluster.

A seguir o comando, instale o controlador de entrada no cluster

Script de criação do Ingress disponível na pasta “ingress”

cd ingress
kubectl apply -f ingress-nginx.yaml

O seguinte comando verifica o controlador de entrada nginx

kubectl get -n ingress-nginx pod

Saída

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

Configurar JFrog Artifactory OSS (código aberto)

Adicione o repositório Helm da comunidade JFrog Artifactory OSS: Para começar, você precisa adicionar o repositório Helm da comunidade JFrog Artifactory OSS ao seu cliente Helm:

Nota: JFrog cria scripts disponíveis na pasta “jfrog”

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

O seguinte comando pode ser usado para verificar a versão do aplicativo e a versão do gráfico dos serviços instalados no cluster:

helm search repo  artifactory-oss

Neste exemplo, estou instalando a versão do carrinho é “107.90.8” e a versão do aplicativo é “7.90.8”

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

Crie um arquivo YAML de valores do Helm chamado helm-value.yaml, que será usado para configurar o serviço JFrog Artifactory OSS. Este arquivo de configuração será utilizado pelo Helm para instalar o serviço no cluster.

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

Na configuração acima, configurei os seguintes pontos:

• Helm está usando o banco de dados PostgreSQL padrão, onde especifiquei a senha do banco de dados.
• Os recursos NGINX e Ingress estão desativados.

O seguinte comando Helm é usado para instalar o Artifactory no cluster. Ele cria os recursos necessários no cluster, incluindo um namespace chamado "artifactory-oss" e instala todos os recursos nesse namespace.

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

Valores do gráfico do Helm: https://github.com/jfrog/charts/blob/master/stable/artifactory-oss/values.yaml

Podemos verificar se todos os recursos foram instalados no namespace "artifactory-oss". A IU do serviço Artifactory está sendo executada na porta 8082, enquanto o próprio Artifactory está operando na porta 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

Precisamos criar um recurso do Ingress para rotear solicitações para o serviço Artifactory. Adicione a seguinte configuração ao arquivo 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

Precisamos configurar proxy-body-size=0. Esta configuração instrui o Ingress a não impor um limite no tamanho do arquivo ao fazer upload de arquivos para o Artifactory.

Execute o seguinte comando para aplicar a entrada no cluster

kubectl apply -f ingress-resource.yaml

Verifique se o endereço IP está definido:

kubectl -n artifactory-oss get ingress

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

Adicione nosso domínio ao final do arquivo /etc/hosts em sua máquina local. Esta configuração não deve estar dentro de nossa caixa Linux funcional “test-jfrog-envornment-box”; ele deve ser aplicado ao arquivo /etc/hosts da sua máquina pessoal.
(você precisará de acesso de administrador):

127.0.0.1 jfrog.artifactory.devops.myapp.com

Podemos abrir a UI do artefato no navegador “http://jfrog.artifactory.devops.myapp.com/”

Você pode fazer login usando o nome de usuário padrão "admin" e a senha "password". Após seu primeiro login, o Artifactory solicitará que você altere a senha padrão. Certifique-se de atualizar a senha, definir o URL base para http://jfrog.artifactory.devops.myapp.com (o domínio configurado no recurso Artifactory Ingress) e pular quaisquer outras etapas de configuração inicial.

Podemos criar as configurações iniciais dos repositórios para enviar as dependências e o binário no artefato.

Navegue até “Artifactory → Artefatos → Gerenciar Repositórios → Criar Repositório” e crie os seguintes repositórios:

• Local: Este repositório gerencia os binários do seu aplicativo. Por exemplo “instantâneo do meu aplicativo”
• Remoto: Este repositório armazena todas as dependências utilizadas em sua aplicação, que serão baixadas dos repositórios centrais e armazenadas no repositório. Por exemplo “my-app-central-snapshot”
• Virtual: Este repositório virtual fornece um endpoint comum que agrega os repositórios “Local” e “Remoto”. Este endpoint será configurado em seu aplicativo. “instantâneo virtual do meu aplicativo”

Estou usando o repositório maven para manter o repositório. Após a configuração, temos que fornecer o repositório local “my-app-snapshot”

Após a configuração, temos que fornecer o repositório local “my-app-central-snapshot”

Após a configuração, temos que fornecer o repositório local “my-app-virtual-snapshot”

Adicione os repositórios locais e remotos ao repositório virtual e selecione o repositório local no “Repositório de implantação padrão”.

Depois que todos os repositórios forem criados, você poderá visualizá-los na seção principal em “Artifactory → Artefatos”. A URL virtual http://jfrog.artifactory.devops.myapp.com/artifactory/my-app-virtual-snapshot/ será usada para seu aplicativo Maven.

Precisamos configurar os detalhes de autenticação no arquivo de configuração do Maven “~/.m2/settings.xml” para permitir que seu aplicativo Maven se autentique com o Artifactory.

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

Nota: O usuário administrador não deve ser usado para acesso à UI e ao Artifactory. Em vez disso, crie um usuário personalizado com permissões apropriadas para leitura e gravação no Artifactory.

Configuramos o repositório maven e as tags de gerenciamento de distribuição dentro de nosso arquivo XML POM do aplicativo 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
    

Podemos implantar o aplicativo maven com o seguinte comando

mvn clean deploy

Podemos obter a seguinte saída do maven:

Referência Git Repo

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