ProHoster > Blog > Administration > Installation et configuration de Nexus Sonatype en utilisant l'approche infrastructure as code

Installation et configuration de Nexus Sonatype en utilisant l'approche infrastructure as code

Sonatype Nexus est une plateforme intégrée qui permet aux développeurs de proxy, stocker et gérer les dépendances Java (Maven), les images Docker, Python, Ruby, NPM, Bower, les paquets RPM, gitlfs, Apt, Go, Nuget, ainsi que de distribuer leur logiciel.

Pourquoi utiliser Sonatype Nexus?

  • Pour le stockage d'artefacts privés;
  • Pour la mise en cache des artefacts téléchargés depuis Internet;

Les artefacts pris en charge dans l'installation de base de Sonatype Nexus :

  • Java, Maven (jar)
  • Docker
  • Python (pip)
  • Ruby (gem)
  • NPM
  • Bower
  • Yum (rpm)
  • gitlfs
  • Raw
  • Apt (deb)
  • Go
  • Nuget

Artefacts pris en charge par la communauté :

  • Composer
  • Conan
  • CPAN
  • ELPA
  • Helm
  • P2
  • R

Installation de Sonatype Nexus en utilisant https://github.com/ansible-ThoTeam/nexus3-oss

Exigences

  • Lisez sur l'utilisation d'ansible sur Internet.
  • Installez ansible pip install ansible sur la station de travail où le playbook sera exécuté.
  • Installez geerlingguy.java sur la station de travail où le playbook sera exécuté.
  • Installez geerlingguy.apache sur la station de travail où le playbook sera exécuté.
  • Ce rôle a été testé sur CentOS 7, Ubuntu Xenial (16.04) et Bionic (18.04), Debian Jessie et Stretch
  • jmespath la bibliothèque doit être installée sur la station de travail où le playbook sera exécuté. Pour l'installation, exécutez sudo pip install -r requirements.txt
  • Enregistrez le fichier playbook (exemple ci-dessous) dans un fichier nexus.yml
  • Lancez l'installation de nexus ansible-playbook -i host nexus.yml

Exemple d'ansible-playbook pour l'installation de nexus sans LDAP avec les dépôts Maven (java), Docker, Python, Ruby, NPM, Bower, RPM et gitlfs.

---
- name: Nexus
  hosts: nexus
  become: yes

  vars:
    nexus_timezone: 'Asia/Omsk'
    nexus_admin_password: "admin123"
    nexus_public_hostname: 'apatsev-nexus-playbook'
    httpd_setup_enable: false
    nexus_privileges:
      - name: all-repos-read
        description: 'Accès en lecture et navigation à tous les dépôts'
        repository: '*'
        actions:
          - read
          - browse
      - name: company-project-deploy
        description: 'Déploiements vers le projet de l'entreprise'
        repository: company-project
        actions:
          - add
          - edit
    nexus_roles:
      - id: Developpers # correspond au groupe LDAP
        name: développeurs
        description: Tous les développeurs
        privileges:
          - nx-search-read
          - all-repos-read
          - company-project-deploy
        roles: []
    nexus_local_users:
      - username: jenkins # utilisé comme clé pour la mise à jour
        first_name: Jenkins
        last_name: CI
        email: support@company.com
        password: "s3cr3t"
        roles:
          - Developpers # ID de rôle ici
    nexus_blobstores:
      - name: company-artifacts
        path: /var/nexus/blobs/company-artifacts
    nexus_scheduled_tasks:
      - name: compact-blobstore
        cron: '0 0 22 * * ?'
        typeId: blobstore.compact
        taskProperties:
          blobstoreName: 'company-artifacts'

    nexus_repos_maven_proxy:
      - name: central
        remote_url: 'https://repo1.maven.org/maven2/'
        layout_policy: permissive
      - name: jboss
        remote_url: 'https://repository.jboss.org/nexus/content/groups/public-jboss/'
      - name: vaadin-addons
        remote_url: 'https://maven.vaadin.com/vaadin-addons/'
      - name: jaspersoft
        remote_url: 'https://jaspersoft.artifactoryonline.com/jaspersoft/jaspersoft-repo/'
        version_policy: mixed
    nexus_repos_maven_hosted:
      - name: company-project
        version_policy: mixed
        write_policy: allow
        blob_store: company-artifacts
    nexus_repos_maven_group:
      - name: public
        member_repos:
          - central
          - jboss
          - vaadin-addons
          - jaspersoft

    # Yum. Change nexus_config_yum to true for create yum repository
    nexus_config_yum: true
    nexus_repos_yum_hosted:
      - name: private_yum_centos_7
        repodata_depth: 1
    nexus_repos_yum_proxy:
      - name: epel_centos_7_x86_64
        remote_url: http://download.fedoraproject.org/pub/epel/7/x86_64
        maximum_component_age: -1
        maximum_metadata_age: -1
        negative_cache_ttl: 60
      - name: centos-7-os-x86_64
        remote_url: http://mirror.centos.org/centos/7/os/x86_64/
        maximum_component_age: -1
        maximum_metadata_age: -1
        negative_cache_ttl: 60
    nexus_repos_yum_group:
      - name: yum_all
        member_repos:
          - private_yum_centos_7
          - epel_centos_7_x86_64

    # NPM. Change nexus_config_npm to true for create npm repository
    nexus_config_npm: true
    nexus_repos_npm_hosted: []
    nexus_repos_npm_group:
      - name: npm-public
        member_repos:
          - npm-registry
    nexus_repos_npm_proxy:
      - name: npm-registry
        remote_url: https://registry.npmjs.org/
        negative_cache_enabled: false

    # Docker. Change nexus_config_docker to true for create docker repository
    nexus_config_docker: true
    nexus_repos_docker_hosted:
      - name: docker-hosted
        http_port: "{{ nexus_docker_hosted_port }}"
        v1_enabled: True
    nexus_repos_docker_proxy:
      - name: docker-proxy
        http_port: "{{ nexus_docker_proxy_port }}"
        v1_enabled: True
        index_type: "HUB"
        remote_url: "https://registry-1.docker.io"
        use_nexus_certificates_to_access_index: false
        maximum_component_age: 1440
        maximum_metadata_age: 1440
        negative_cache_enabled: true
        negative_cache_ttl: 1440
    nexus_repos_docker_group:
      - name: docker-group
        http_port: "{{ nexus_docker_group_port }}"
        v1_enabled: True
        member_repos:
          - docker-hosted
          - docker-proxy

    # Bower. Change nexus_config_bower to true for create bower repository
    nexus_config_bower: true
    nexus_repos_bower_hosted:
      - name: bower-hosted
    nexus_repos_bower_proxy:
      - name: bower-proxy
        index_type: "proxy"
        remote_url: "https://registry.bower.io"
        use_nexus_certificates_to_access_index: false
        maximum_component_age: 1440
        maximum_metadata_age: 1440
        negative_cache_enabled: true
        negative_cache_ttl: 1440
    nexus_repos_bower_group:
      - name: bower-group
        member_repos:
          - bower-hosted
          - bower-proxy

    # Pypi. Change nexus_config_pypi to true for create pypi repository
    nexus_config_pypi: true
    nexus_repos_pypi_hosted:
      - name: pypi-hosted
    nexus_repos_pypi_proxy:
      - name: pypi-proxy
        index_type: "proxy"
        remote_url: "https://pypi.org/"
        use_nexus_certificates_to_access_index: false
        maximum_component_age: 1440
        maximum_metadata_age: 1440
        negative_cache_enabled: true
        negative_cache_ttl: 1440
    nexus_repos_pypi_group:
      - name: pypi-group
        member_repos:
          - pypi-hosted
          - pypi-proxy

    # rubygems. Change nexus_config_rubygems to true for create rubygems repository
    nexus_config_rubygems: true
    nexus_repos_rubygems_hosted:
      - name: rubygems-hosted
    nexus_repos_rubygems_proxy:
      - name: rubygems-proxy
        index_type: "proxy"
        remote_url: "https://rubygems.org"
        use_nexus_certificates_to_access_index: false
        maximum_component_age: 1440
        maximum_metadata_age: 1440
        negative_cache_enabled: true
        negative_cache_ttl: 1440
    nexus_repos_rubygems_group:
      - name: rubygems-group
        member_repos:
          - rubygems-hosted
          - rubygems-proxy

    # gitlfs. Change nexus_config_gitlfs to true for create gitlfs repository
    nexus_config_gitlfs: true
    nexus_repos_gitlfs_hosted:
      - name: gitlfs-hosted

  roles:
    - { role: geerlingguy.java }
    # Debian/Ubuntu only
    # - { role: geerlingguy.apache, apache_create_vhosts: no, apache_mods_enabled: ["proxy_http.load", "headers.load"], apache_remove_default_vhost: true, tags: ["geerlingguy.apache"] }
    # RedHat/CentOS only
    - { role: geerlingguy.apache, apache_create_vhosts: no, apache_remove_default_vhost: true, tags: ["geerlingguy.apache"] }
    - { role: ansible-thoteam.nexus3-oss, tags: ['ansible-thoteam.nexus3-oss'] }

Captures d'écran :

Installation et configuration de Nexus Sonatype en utilisant l'approche infrastructure as code

Installation et configuration de Nexus Sonatype en utilisant l'approche infrastructure as code

Variables de rôle

Variables de rôle

Variables avec valeurs par défaut (voir default/main.yml):

Variables générales

    nexus_version: ''
    nexus_timezone: 'UTC'

Par défaut, le rôle installera la dernière version disponible de Nexus. Vous pouvez spécifier la version en modifiant la variable nexus_version. Voir les versions disponibles sur https://www.sonatype.com/download-oss-sonatype.

Si vous changez la version pour une version plus récente, le rôle tentera de mettre à jour votre Nexus installé.

Si vous utilisez une version de Nexus plus ancienne que la dernière, vous devez vous assurer que vous n'utilisez pas de fonctionnalités qui ne sont pas disponibles dans la version installée (par exemple, l'hébergement de dépôts yum est disponible pour Nexus supérieur à 3.8.0, le dépôt git lfs pour Nexus supérieur à 3.3.0, etc.)

Fuseau horaire Nexus — est le nom du fuseau horaire Java qui peut être utile en combinaison avec les expressions cron ci-dessous pour des tâches planifiées Nexus.

Port Nexus et chemin de contexte

    nexus_default_port: 8081
    nexus_default_context_path: '\/''

Port et chemin de contexte du processus de connexion Java. nexus_default_context_path doit contenir une barre oblique lorsqu'il est défini, par exemple : nexus_default_context_path: '\/nexus\/'.

Utilisateur et groupe OS Nexus

    nexus_os_group: 'nexus'
    nexus_os_user: 'nexus'

L'utilisateur et le groupe utilisés pour posséder les fichiers Nexus et exécuter le service seront créés par le rôle, s'ils n'existent pas.

    nexus_os_user_home_dir: '\/home\/nexus'

Autoriser la modification du répertoire personnel par défaut pour l'utilisateur nexus

Répertoires des instances Nexus

    nexus_installation_dir: '\/opt'
    nexus_data_dir: '\/var\/nexus'
    nexus_tmp_dir: "{{ (ansible_os_family == 'RedHat') | ternary('\/var\/nexus-tmp', '\/tmp\/nexus') }}"

Répertoires Nexus.

  • nexus_installation_dir contient les fichiers exécutables installés
  • nexus_data_dir contient toute la configuration, les dépôts et les artefacts téléchargés. Les chemins personnalisés des blobstores nexus_data_dir peuvent être configurés, voir ci-dessous nexus_blobstores.
  • nexus_tmp_dir contient tous les fichiers temporaires. Le chemin par défaut pour redhat a été déplacé de /tmp pour surmonter les problèmes potentiels avec les procédures automatiques de nettoyage. Voir #168.

Configuration de l'utilisation de la mémoire de la JVM Nexus

    nexus_min_heap_size: "1200M"
    nexus_max_heap_size: "{{ nexus_min_heap_size }}"
    nexus_max_direct_memory: "2G"

Ce sont les paramètres par défaut pour Nexus. Veuillez ne pas modifier ces valeurs. Si vous n'avez pas lu la section sur la mémoire des exigences système de Nexus et ne comprenez pas ce qu'elles font.

Comme second avertissement, voici un extrait du document mentionné ci-dessus :

Il n'est pas recommandé d'augmenter la mémoire JVM heap au-delà des valeurs recommandées dans le but d'améliorer les performances. Cela peut en fait avoir l'effet inverse, entraînant un travail inutile du système d'exploitation.

Mot de passe administrateur

    nexus_admin_password: 'changeme'

Mot de passe du compte « admin » pour la configuration. Cela fonctionne uniquement lors de la première installation par défaut. Veuillez consulter [Modifier le mot de passe administrateur après la première installation](# change-admin-password-after-first-install) si vous souhaitez le modifier plus tard avec un rôle.

Il est fortement déconseillé de stocker votre mot de passe en texte clair dans le playbook, mais d'utiliser [le chiffrement ansible-vault] (https://docs.ansible.com/ansible/latest/user_guide/vault.html) (soit intégré, soit dans un fichier séparé chargé, par exemple, avec include_vars)

Accès anonyme par défaut

    nexus_anonymous_access: false

L'accès anonyme par défaut est désactivé. En savoir plus sur l'accès anonyme.

Nom d'hôte public

    nexus_public_hostname: 'nexus.vm'
    nexus_public_scheme: https

Nom de domaine complet et schéma (https ou http) par lequel l'instance Nexus sera accessible pour ses clients.

Accès API pour ce rôle

    nexus_api_hostname: localhost
    nexus_api_scheme: http
    nexus_api_validate_certs: "{{ nexus_api_scheme == 'https' }}"
    nexus_api_context_path: "{{ nexus_default_context_path }}"
    nexus_api_port: "{{ nexus_default_port }}"

Ces variables contrôlent comment le rôle se connecte à l'API Nexus pour la fourniture.
Réservé aux utilisateurs avancés. Vous ne souhaitez probablement pas modifier ces paramètres par défaut.

Configuration du proxy inverse

    httpd_setup_enable: false
    httpd_server_name: "{{ nexus_public_hostname }}"
    httpd_default_admin_email: "admin@example.com"
    httpd_ssl_certificate_file: 'files/nexus.vm.crt'
    httpd_ssl_certificate_key_file: 'files/nexus.vm.key'
    # httpd_ssl_certificate_chain_file: "{{ httpd_ssl_certificate_file }}"
    httpd_copy_ssl_files: true

Installez Serveur proxy inverse SSL.
Pour cela, httpd doit être installé. Remarque : lorsque httpd_setup_enable est défini surtrue, nexus se connecte à 127.0.0.1:8081, permettant ainsi ne d'être accessible directement via le port HTTP 8081 avec une adresse IP externe.

Le nom d'hôte par défaut utilisé est nexus_public_hostname. Si vous avez besoin de différents noms pour une raison quelconque, vous pouvez définir httpd_server_name avec une autre valeur.

Avec httpd_copy_ssl_files: true (par défaut) les certificats mentionnés ci-dessus doivent exister dans votre répertoire de playbook et seront copiés sur le serveur et configurés dans apache.

Si vous souhaitez utiliser des certificats existants sur le serveur, définissez httpd_copy_ssl_files: false et fournissez les variables suivantes :

    # These specifies to the vhost where to find on the remote server file
    # system the certificate files.
    httpd_ssl_cert_file_location: "/etc/pki/tls/certs/wildcard.vm.crt"
    httpd_ssl_cert_key_location: "/etc/pki/tls/private/wildcard.vm.key"
    # httpd_ssl_cert_chain_file_location: "{{ httpd_ssl_cert_file_location }}"

emplacement_du_fichier_de_chaîne_de_certificats_ssl_httpd est optionnel et doit rester non configuré si vous ne souhaitez pas configurer le fichier de chaîne

    httpd_email_admin_par_défaut: "admin@example.com"

Définir l'adresse e-mail de l'administrateur par défaut

Configuration LDAP

Les connexions LDAP et la zone de sécurité par défaut sont désactivées

    nexus_ldap_realm: false
    ldap_connections: []

Connexions LDAP, chaque élément ressemble à ceci :

    nexus_ldap_realm: true
    ldap_connections:
      - ldap_name: 'Mon LDAP d'entreprise' # utilisé comme clé pour mettre à jour la configuration ldap
        ldap_protocol: 'ldaps' # ldap ou ldaps
        ldap_hostname: 'ldap.monentreprise.com'
        ldap_port: 636
        ldap_use_trust_store: false # Que ce soit ou non pour utiliser les certificats dans le magasin de confiance nexus
        ldap_search_base: 'dc=monentreprise,dc=net'
        ldap_auth: 'none' # ou simple
        ldap_auth_username: 'nom_utilisateur' # si auth = simple
        ldap_auth_password: 'motdepasse' # si auth = simple
        ldap_user_base_dn: 'ou=utilisateurs'
        ldap_user_filter: '(cn=*)' # (facultatif)
        ldap_user_object_class: 'inetOrgPerson'
        ldap_user_id_attribute: 'uid'
        ldap_user_real_name_attribute: 'cn'
        ldap_user_email_attribute: 'mail'
        ldap_user_subtree: false
        ldap_map_groups_as_roles: false
        ldap_group_base_dn: 'ou=groupes'
        ldap_group_object_class: 'posixGroup'
        ldap_group_id_attribute: 'cn'
        ldap_group_member_attribute: 'memberUid'
        ldap_group_member_format: '${nom_utilisateur}'
        ldap_group_subtree: false

Exemple de configuration LDAP pour l'authentification anonyme (liaison anonyme), c'est aussi une configuration « minimale » :

    nexus_ldap_realm: true
    ldap_connection:
      - ldap_name: 'Configuration LDAP la plus simple'
        ldap_protocol: 'ldaps'
        ldap_hostname: 'annuaire.monentreprise.com'
        ldap_search_base: 'dc=monentreprise,dc=net'
        ldap_port: 636
        ldap_use_trust_store: false
        ldap_user_id_attribute: 'uid'
        ldap_user_real_name_attribute: 'cn'
        ldap_user_email_attribute: 'mail'
        ldap_user_object_class: 'inetOrgPerson'

Exemple de configuration LDAP pour l'authentification simple (en utilisant un compte DSA) :

    nexus_ldap_realm: true
    ldap_connections:
      - ldap_name: 'Configuration LDAP avec DSA'
        ldap_protocol: 'ldaps'
        ldap_hostname: 'annuaire.monentreprise.com'
        ldap_port: 636
        ldap_use_trust_store: false
        ldap_auth: 'simple'
        ldap_auth_username: 'cn=mynexus,ou=dsa,dc=monentreprise,dc=net'
        ldap_auth_password: "{{ vault_ldap_dsa_password }}" # mieux vaut garder les mots de passe dans un coffre Ansible
        ldap_search_base: 'dc=monentreprise,dc=net'
        ldap_user_base_dn: 'ou=utilisateurs'
        ldap_user_object_class: 'inetOrgPerson'
        ldap_user_id_attribute: 'uid'
        ldap_user_real_name_attribute: 'cn'
        ldap_user_email_attribute: 'mail'
        ldap_user_subtree: false

Exemple de configuration LDAP pour l'authentification simple (en utilisant un compte DSA) + groupes associés comme rôles :

    nexus_ldap_realm: true
    ldap_connections
      - ldap_name: 'Configuration LDAP avec DSA'
        ldap_protocol: 'ldaps'
        ldap_hostname: 'annuaire.mycompany.com'
        ldap_port: 636
        ldap_use_trust_store: false
        ldap_auth: 'simple'
        ldap_auth_username: 'cn=mynexus,ou=dsa,dc=mycompany,dc=net'
        ldap_auth_password: "{{ vault_ldap_dsa_password }}" # mieux garder les mots de passe dans un coffre ansible
        ldap_search_base: 'dc=mycompany,dc=net'
        ldap_user_base_dn: 'ou=users'
        ldap_user_object_class: 'inetOrgPerson'
        ldap_user_id_attribute: 'uid'
        ldap_user_real_name_attribute: 'cn'
        ldap_user_email_attribute: 'mail'
        ldap_map_groups_as_roles: true
        ldap_group_base_dn: 'ou=groups'
        ldap_group_object_class: 'groupOfNames'
        ldap_group_id_attribute: 'cn'
        ldap_group_member_attribute: 'member'
        ldap_group_member_format: 'uid=${username},ou=users,dc=mycompany,dc=net'
        ldap_group_subtree: false

Exemple de configuration LDAP pour l'authentification simple (utilisant un compte DSA) + groupes, associés dynamiquement comme rôles :

    nexus_ldap_realm: true
    ldap_connections:
      - ldap_name: 'Configuration LDAP avec DSA'
        ldap_protocol: 'ldaps'
        ldap_hostname: 'annuaire.mycompany.com'
        ldap_port: 636
        ldap_use_trust_store: false
        ldap_auth: 'simple'
        ldap_auth_username: 'cn=mynexus,ou=dsa,dc=mycompany,dc=net'
        ldap_auth_password: "{{ vault_ldap_dsa_password }}" # mieux garder les mots de passe dans un coffre ansible
        ldap_search_base: 'dc=mycompany,dc=net'
        ldap_user_base_dn: 'ou=users'
        ldap_user_object_class: 'inetOrgPerson'
        ldap_user_id_attribute: 'uid'
        ldap_user_real_name_attribute: 'cn'
        ldap_user_email_attribute: 'mail'
        ldap_map_groups_as_roles: true
        ldap_map_groups_as_roles_type: 'dynamic'
        ldap_user_memberof_attribute: 'memberOf'

Privilèges

    nexus_privileges:
      - name: all-repos-read # utilisé comme clé pour mettre à jour un privilège
        # type: <un des suivants : application, repository-admin, repository-content-selector, repository-view, script ou wildcard>
        description: 'Accès lecture & navigation à tous les dépôts'
        repository: '*'
        actions: # peuvent être add, browse, create, delete, edit, read ou * (tout)
          - read
          - browse
        # pattern: motif
        # domain: domaine
        # script_name: nom

La liste de privilèges pour la configuration. Consultez la documentation et l'interface graphique pour vérifier quelles variables doivent être définies en fonction du type de privilège.

Ces éléments sont combinés avec les valeurs par défaut suivantes :

    _nexus_privilege_defaults:
      type: repository-view
      format: maven2
      actions:
        - read

Rôles (dans le sens de Nexus)

    nexus_roles:
      - id: Developpers # peut être mappé à un ID de groupe LDAP, utilisé également comme clé pour mettre à jour un rôle
        name: developers
        description: Tous les développeurs
        privileges:
          - nx-search-read
          - all-repos-read
        roles: [] # références à d'autres noms de rôle

La liste rôles pour la configuration.

Utilisateurs

    nexus_local_users: []
      # - username: jenkins # utilisé comme clé pour mettre à jour
      #   state: present # valeur par défaut si omise, utiliser 'absent' pour supprimer l'utilisateur
      #   first_name: Jenkins
      #   last_name: CI
      #   email: support@company.com
      #   password: "s3cr3t"
      #   roles:
      #     - developers # ID de rôle

Liste des utilisateurs/comptes locaux (non-LDAP) à créer dans Nexus.

Liste des utilisateurs/comptes locaux (non LDAP) à créer dans Nexus.

      nexus_ldap_users: []
      # - nom d'utilisateur: j.doe
      #   état: présent
      #   rôles:
      #     - "nx-admin"

Mapping des utilisateurs/rôles LDAP. État absent supprime des rôles d'un utilisateur existant, s'il existe déjà.
Les utilisateurs LDAP ne sont pas supprimés. Essayer d'attribuer un rôle à un utilisateur inexistant entraînera une erreur.

Selecteurs de contenu

  nexus_content_selectors:
  - nom: docker-login
    description: Sélecteur pour le privilège de connexion Docker
    search_expression: format=="docker" and path=~"/v2/"

Pour plus d'informations sur le sélecteur de contenu, voir la documentation.

Pour utiliser le sélecteur de contenu, ajoutez un nouveau privilège avec type: repository-content-selector et le correspondantcontentSelector

- nom: docker-login-privilege
  type: repository-content-selector
  contentSelector: docker-login
  description: 'Connexion au registre Docker'
  repository: '*'
  actions:
  - lire
  - parcourir

Blobstores et dépôts

    nexus_delete_default_repos: false

Supprimer les dépôts de la configuration par défaut initiale de Nexus. Cette étape n'est exécutée que lors de la première installation (lorsque nexus_data_dir a été détecté comme vide).

Suppression des dépôts de la configuration par défaut de Nexus. Cette étape est effectuée uniquement lors de la première installation (lorsque nexus_data_dir est vide).

    nexus_delete_default_blobstore: false

Supprimer le blobstore par défaut de la configuration par défaut initiale de Nexus. Cela ne peut être fait que si nexus_delete_default_repos: true et tous les dépôts configurés (voir ci-dessous) ont un blob_store: custom. Cette étape n'est exécutée que lors de la première installation (lorsque nexus_data_dir a été détecté comme vide).

La suppression du stockage des blobs (artéfacts binaires) est désactivée par défaut dans la configuration initiale. Pour supprimer le stockage des blobs (artéfacts binaires), désactivez nexus_delete_default_repos: true. Cette étape n'est exécutée que lors de la première installation (lorsque nexus_data_dir est vide).

    nexus_blobstores: []
    # exemple d'élément de blobstore :
    # - nom: separate-storage
    #   type: file
    #   chemin: /mnt/custom/path
    # - nom: s3-blobstore
    #   type: S3
    #   config:
    #     bucket: s3-blobstore
    #     accessKeyId: "{{ VAULT_ENCRYPTED_KEY_ID }}"
    #     secretAccessKey: "{{ VAULT_ENCRYPTED_ACCESS_KEY }}"

Blobstores à créer. Un chemin de blobstore et un blobstore de dépôt ne peuvent pas être mis à jour après la création initiale (toute mise à jour ici sera ignorée lors de la reprovisionnement).

La configuration du blobstore sur S3 est fournie pour des raisons pratiques et ne fait pas partie des tests automatisés que nous effectuons sur travis. Veuillez noter que le stockage sur S3 n'est recommandé que pour les instances déployées sur AWS.

Création Blobstores. Le chemin vers le stockage et le dépôt de stockage ne peuvent pas être mis à jour après la création initiale (toute mise à jour ici sera ignorée lors de la réinstallation).

La configuration du stockage des objets BLOB sur S3 est fournie pour la commodité. Veuillez noter que le stockage sur S3 est recommandé uniquement pour les instances déployées sur AWS.

    nexus_repos_maven_proxy:
      - name: central
        remote_url: 'https://repo1.maven.org/maven2/'
        layout_policy: permissive
        # maximum_component_age: -1
        # maximum_metadata_age: 1440
        # negative_cache_enabled: true
        # negative_cache_ttl: 1440
      - name: jboss
        remote_url: 'https://repository.jboss.org/nexus/content/groups/public-jboss/'
        # maximum_component_age: -1
        # maximum_metadata_age: 1440
        # negative_cache_enabled: true
        # negative_cache_ttl: 1440
    # exemple avec un nom d'utilisateur/mot de passe :
    # - name: secret-remote-repo
    #   remote_url: 'https://company.com/repo/secure/private/go/away'
    #   remote_username: 'username'
    #   remote_password: 'secret'
    #   # maximum_component_age: -1
    #   # maximum_metadata_age: 1440
    #   # negative_cache_enabled: true
    #   # negative_cache_ttl: 1440

Ci-dessus un exemple de configuration proxy Maven.

    nexus_repos_maven_hosted:
      - name: private-release
        version_policy: release
        write_policy: allow_once  # l'un de "allow", "allow_once" ou "deny"

Maven dépôts hébergés configuration. La configuration du cache négatif est facultative et prendra par défaut les valeurs ci-dessus si elle est omise.

Configuration dépôts hébergés Maven. La configuration du cache négatif (-1) est facultative et utilisera par défaut les valeurs ci-dessus si elle n'est pas spécifiée.

    nexus_repos_maven_group:
      - name: public
        member_repos:
          - central
          - jboss

Configuration groupes Maven.

Les trois types de dépôts sont combinés avec les valeurs par défaut suivantes :

    _nexus_repos_maven_defaults:
      blob_store: default # Remarque : ne peut pas être mis à jour une fois le dépôt créé
      strict_content_validation: true
      version_policy: release # release, snapshot ou mixed
      layout_policy: strict # strict ou permissif
      write_policy: allow_once # l'un de "allow", "allow_once" ou "deny"
      maximum_component_age: -1  # valeur par défaut de l'interface Nexus. Pour les proxies uniquement
      maximum_metadata_age: 1440  # valeur par défaut de l'interface Nexus. Pour les proxies uniquement
      negative_cache_enabled: true # valeur par défaut de l'interface Nexus. Pour les proxies uniquement
      negative_cache_ttl: 1440 # valeur par défaut de l'interface Nexus. Pour les proxies uniquement

Types de dépôts Docker, Pypi, Raw, Rubygems, Bower, NPM, Git-LFS et yum :
voir defaults/main.yml pour ces options :

Les dépôts Docker, Pypi, Raw, Rubygems, Bower, NPM, Git-LFS et yum sont désactivés par défaut :
Voir defaults/main.yml pour ces options :

      nexus_config_pypi: false
      nexus_config_docker: false
      nexus_config_raw: false
      nexus_config_rubygems: false
      nexus_config_bower: false
      nexus_config_npm: false
      nexus_config_gitlfs: false
      nexus_config_yum: false

Veuillez noter que vous pourriez avoir besoin d'activer certaines zones de sécurité si vous souhaitez utiliser d'autres types de dépôts en dehors de Maven. Cela est désactivé par défaut

nexus_nuget_api_key_realm: false
nexus_npm_bearer_token_realm: false
nexus_docker_bearer_token_realm: false  # requis pour l'accès anonyme à Docker

Le royaume d'utilisateur distant peut également être activé via

nexus_rut_auth_realm: true

et l'en-tête peut être configuré en définissant

nexus_rut_auth_header: "CUSTOM_HEADER"

Tâches planifiées

    nexus_scheduled_tasks: []
    #  #  Exemple de tâche pour compacter le blobstore :
    #  - nom: compact-docker-blobstore
    #    cron: '0 0 22 * * ?'
    #    typeId: blobstore.compact
    #    task_alert_email: alerts@example.org  # optionnel
    #    taskProperties:
    #      blobstoreName: {{ nexus_blob_names.docker.blob }} # tous les attributs de tâche sont stockés sous forme de chaînes par nexus en interne
    #  #  Exemple de tâche pour purger les snapshots maven
    #  - nom: Purge-maven-snapshots
    #    cron: '0 50 23 * * ?'
    #    typeId: repository.maven.remove-snapshots
    #    task_alert_email: alerts@example.org  # optionnel
    #    taskProperties:
    #      repositoryName: "*"  # * pour tous les dépôts. Changez pour un nom de dépôt si vous ne voulez qu'un spécifique
    #      minimumRetained: "2"
    #      snapshotRetentionDays: "2"
    #      gracePeriodInDays: "2"
    #    booleanTaskProperties:
    #      removeIfReleased: true
    #  #  Exemple de tâche pour purger les manifests et images docker inutilisés
    #  - nom: Purge des manifests et images docker inutilisés
    #    cron: '0 55 23 * * ?'
    #    typeId: "repository.docker.gc"
    #    task_alert_email: alerts@example.org  # optionnel
    #    taskProperties:
    #      repositoryName: "*"  # * pour tous les dépôts. Changez pour un nom de dépôt si vous ne voulez qu'un spécifique
    #  #  Exemple de tâche pour purger les uploads docker incomplets
    #  - nom: Purge des uploads docker incomplets
    #    cron: '0 0 0 * * ?'
    #    typeId: "repository.docker.upload-purge"
    #    task_alert_email: alerts@example.org  # optionnel
    #    taskProperties:
    #      age: "24"

Tâches planifiées pour la configuration. typeId et spécifiques à la tâchetaskProperties/booleanTaskProperties peut être deviné comme :

  • de la hiérarchie des types Java org.sonatype.nexus.scheduling.TaskDescriptorSupport
  • en vérifiant le formulaire HTML de création de tâche dans votre navigateur
  • en regardant les requêtes AJAX dans le navigateur lors de la configuration manuelle de la tâche.

Les propriétés de la tâche doivent être déclarées dans le bon bloc yaml selon leur type:

  • taskProperties pour toutes les propriétés de chaîne (c'est-à-dire les noms de dépôts, les noms de blobstores, les périodes de temps ...).
  • booleanTaskProperties pour toutes les propriétés booléennes (c'est-à-dire principalement les cases à cocher dans l'interface graphique de création de tâche de nexus).

Sauvegardes

      nexus_backup_configure: false
      nexus_backup_cron: '0 0 21 * * ?'  # Voir la définition des expressions cron dans l'interface de création de tâche de nexus
      nexus_backup_dir: '\/var\/nexus-backup'
      nexus_restore_log: '{{ nexus_backup_dir }}\/nexus-restore.log'
      nexus_backup_rotate: false
      nexus_backup_rotate_first: false
      nexus_backup_keep_rotations: 4  # Conserver 4 rotations de sauvegarde par défaut (actuelle + dernières 3)

La sauvegarde ne sera pas configurée tant que vous ne l'aurez pas activée nexus_backup_configure dans true.
Dans ce cas, la tâche planifiée sera configurée pour s'exécuter dans Nexus
à l'intervalle indiqué dans nexus_backup_cron (par défaut 21:00 chaque jour).
Voir [le modèle groovy pour cette tâche](templates \/ backup.groovy.j2) pour plus de détails.
Cette tâche planifiée ne dépend pas des autres nexus_scheduled_tasks, que vous avez
déclarées dans votre playbook.

Si vous souhaitez faire pivoter/supprimer les sauvegardes, définissez nexus_backup_rotate: true et configurez le nombre de sauvegardes que vous souhaitez conserver avec nexus_backup_keep_rotations (par défaut 4).

Lors de l'utilisation de la rotation, si vous souhaitez économiser de l'espace disque supplémentaire pendant le processus de sauvegarde,
Vous pouvez définir nexus_backup_rotate_first: true. Cela configurera une rotation/suppression préalable avant la sauvegarde. Par défaut, la rotation se produit après la création de la sauvegarde. Notez que dans ce cas, les anciennes sauvegardes
seront supprimées avant que la sauvegarde actuelle ne soit effectuée.

Procédure de restauration

Exécutez le playbook avec le paramètre -e nexus_restore_point=
(par exemple, 2017-12-17-21-00-00 pour le 17 décembre 2017 à 21h00

Suppression de nexus

Avertissement : cela supprimera complètement les données actuelles. Assurez-vous de faire une sauvegarde au préalable si nécessaire.

Utilisez la variable nexus_purge, si vous devez repartir de zéro et réinstaller une instance nexus en supprimant toutes les données.

ansible-playbook -i your/inventory.ini your_nexus_playbook.yml -e nexus_purge=true

Changer le mot de passe administrateur après la première installation

    nexus_default_admin_password: 'admin123'

Cela ne doit pas être changé dans votre playbook. Cette variable est remplie avec le mot de passe administrateur standard de Nexus lors de la première installation et garantit que nous pouvons changer le mot de passe administrateur en nexus_admin_password.

Si vous souhaitez changer le mot de passe administrateur après la première installation, vous pouvez temporairement le changer en l'ancien mot de passe via la ligne de commande. Après ce changement, nexus_admin_password dans votre livre de jeux, vous pouvez exécuter :

ansible-playbook -i your/inventory.ini your_playbook.yml -e nexus_default_admin_password=oldPassword

Canal Telegram sur Nexus Sonatype : https://t.me/ru_nexus_sonatype

Seuls les utilisateurs enregistrés peuvent participer au sondage. Connectez-vous, s'il vous plaît.

Quels repositories d'artefacts utilisez-vous ?

  • Sonatype Nexus gratuit

  • Sonatype Nexus payant

  • Artifactory gratuit

  • Artifactory payant

  • Harbor

  • Pulp

9 utilisateurs ont voté. 3 utilisateurs se sont abstenus.

Source : habr.com

Acheter un hébergement fiable pour les sites avec protection DDoS, serveurs VPS VDS 🔥 Acheter un hébergement fiable pour les sites avec protection DDoS, serveurs VPS VDS | ProHoster