Registry OCI

Vue d'ensemble

À la livraison de votre cluster Kubernetes, SdV vous met à disposition une instance de registry OCI (Open Container Initiative), reposant sur le produit Harbor.

Harbor est une solution de registry d'entreprise open-source qui permet de stocker, signer et scanner les images de conteneurs Docker et OCI. Elle offre des fonctionnalités avancées de gestion, de sécurité et de conformité pour vos artefacts conteneurisés.

Fonctionnalités principales

Accès au registry Harbor

URL et authentification

Lors de la livraison du cluster, SdV vous fournit :

• URL du registry : fournie à la livraison du cluster
• Interface Web : accessible via un navigateur pour la gestion visuelle
• API REST : pour les intégrations automatisées
• Identifiants d'un compte administrateur initial

Connexion à l'interface web

1. Accédez à l'URL de votre registry Harbor via un navigateur
2. Authentifiez-vous avec vos identifiants
3. Vous accédez au tableau de bord listant vos projets et statistiques

Authentification Docker CLI

Pour pousser ou récupérer des images via la ligne de commande :

# Connexion au registry Harbor
docker login {URL_HARBOR}
 
# Saisir votre nom d'utilisateur et mot de passe
# Les credentials sont stockés dans ~/.docker/config.json

Gestion des projets

Structure organisationnelle

Harbor organise les images en projets, qui regroupent un ou plusieurs repositories. Cette hiérarchie facilite la gestion des droits et la séparation des environnements.

harbor-votre-cluster.sdv.fr/
├── production/
│   ├── frontend:1.0.0
│   ├── backend:2.3.1
│   └── api:latest
├── staging/
│   ├── frontend:develop
│   └── backend:feature-xyz
└── shared-libs/
    ├── base-nginx:1.21
    └── python-base:3.11-alpine

Création d'un projet

Via l'interface web :

1. Cliquez sur "New Project"
2. Définissez le nom (ex : production, staging, team-backend)
3. Choisissez la visibilité :
   • Private : accessible seulement aux membres autorisés (recommandé)
   • Public : accessible en lecture à tous les utilisateurs authentifiés
4. Activez les options selon vos besoins :
   • Scan automatique : scan de vulnérabilités au push
   • Prévention des images vulnérables : blocage du pull si CVE critiques détectées
   • Content Trust : signature obligatoire des images

Robot Accounts

Les Robot Accounts sont des comptes de service dédiés aux automatisations (CI/CD, Kubernetes, scripts). Ils peuvent être limités à un projet spécifique avec des droits restreints.

Création d'un Robot Account

1. Dans votre projet, allez dans "Robot Accounts"
2. Cliquez sur "New Robot Account"
3. Définissez un nom explicite (ex : gitlab-ci-pusher, k8s-puller)
4. Sélectionnez les permissions :
   • Push artifact : droit de pousser des images
   • Pull artifact : droit de récupérer des images
   • Delete artifact : droit de supprimer des images (attention !)
5. Récupérez le token généré et conservez-le en sécurité

Utilisation dans un pipeline CI/CD

stages:
  - build
  - push
 
variables:
  HARBOR_REGISTRY: "harbor.k8s-prod.sdv.fr"
  HARBOR_PROJECT: "production"
  IMAGE_NAME: "backend"
  IMAGE_TAG: "${CI_COMMIT_SHORT_SHA}"
 
build:
  stage: build
  image: docker:24-dind
  services:
    - docker:24-dind
  before_script:
    - echo "${HARBOR_ROBOT_TOKEN}" | docker login -u "${HARBOR_ROBOT_USER}" --password-stdin ${HARBOR_REGISTRY}
  script:
    - docker build -t ${HARBOR_REGISTRY}/${HARBOR_PROJECT}/${IMAGE_NAME}:${IMAGE_TAG} .
    - docker tag ${HARBOR_REGISTRY}/${HARBOR_PROJECT}/${IMAGE_NAME}:${IMAGE_TAG} ${HARBOR_REGISTRY}/${HARBOR_PROJECT}/${IMAGE_NAME}:latest
    - docker push ${HARBOR_REGISTRY}/${HARBOR_PROJECT}/${IMAGE_NAME}:${IMAGE_TAG}
    - docker push ${HARBOR_REGISTRY}/${HARBOR_PROJECT}/${IMAGE_NAME}:latest
  only:
    - main

Utilisation du registry

Push d'une image

# Construire une image localement
docker build -t mon-app:1.0.0 .
 
# Tagger l'image avec le chemin complet du registry
docker tag mon-app:1.0.0 harbor-votre-cluster.sdv.fr/production/mon-app:1.0.0
 
# Pousser l'image vers Harbor
docker push harbor-votre-cluster.sdv.fr/production/mon-app:1.0.0

Pull d'une image

# Récupérer une image depuis Harbor
docker pull harbor-votre-cluster.sdv.fr/production/mon-app:1.0.0
 
# Lancer un conteneur avec cette image
docker run -d harbor-votre-cluster.sdv.fr/production/mon-app:1.0.0

Stratégies de tagging

Scan de vulnérabilités

Harbor intègre Trivy (scanner de vulnérabilités open-source) pour analyser automatiquement les images et détecter les CVE (Common Vulnerabilities and Exposures).

Fonctionnement

• Scan automatique au push : configurable au niveau du projet
• Scan manuel : déclenchable via l'interface web ou l'API
• Base de données CVE : mise à jour régulièrement pour détecter les dernières vulnérabilités

Niveaux de sévérité

Politique de blocage

Vous pouvez configurer Harbor pour empêcher le pull d'images vulnérables :

1. Dans les paramètres du projet, activez "Prevent vulnerable images from running"
2. Définissez le seuil : Critical, Critical+High, etc.
3. Les images ne respectant pas le seuil ne pourront pas être déployées

Visualisation des résultats

Dans l'interface Harbor :

1. Accédez à votre repository
2. Cliquez sur une image/tag spécifique
3. Consultez l'onglet "Vulnerabilities"
4. Vous verrez la liste des CVE détectées avec leur sévérité, description et solution

Intégration avec Kubernetes

Authentification via Secret

Pour permettre à Kubernetes de récupérer des images depuis Harbor, créez un Secret de type docker-registry :

kubectl create secret docker-registry harbor-credentials \
  --docker-server=harbor-votre-cluster.sdv.fr \
  --docker-username='robot$production+k8s-puller' \
  --docker-password=VOTRE_TOKEN_ROBOT \
  --namespace=production

Utilisation dans un Pod

Référencez le Secret dans votre Deployment pour autoriser le pull depuis Harbor :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-application
  namespace: production
  labels:
    app: mon-application
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      # Référence au Secret pour l'authentification Harbor
      imagePullSecrets:
        - name: harbor-credentials
      containers:
        - name: backend
          image: harbor.k8s-prod.sdv.fr/production/backend:1.2.3
          ports:
            - containerPort: 8080
              name: http
          resources:
            requests:
              memory: "256Mi"
              cpu: "100m"
            limits:
              memory: "512Mi"
              cpu: "500m"

ServiceAccount avec imagePullSecrets

Pour éviter de répéter imagePullSecrets dans chaque Deployment, attachez-le au ServiceAccount :

apiVersion: v1
kind: ServiceAccount
metadata:
  name: app-serviceaccount
  namespace: production
imagePullSecrets:
  - name: harbor-credentials

Puis référencez ce ServiceAccount dans vos Pods :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-application
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      serviceAccountName: app-serviceaccount
      containers:
        - name: backend
          image: harbor.k8s-prod.sdv.fr/production/backend:1.2.3
          ports:
            - containerPort: 8080

Gestion du stockage

Quotas de stockage

Les projets Harbor peuvent être soumis à des quotas de stockage pour limiter l'espace disque consommé.

• Quota par défaut : défini lors de la création du projet ou configuré globalement
• Quota personnalisé : ajustable par projet selon vos besoins
• Notification : alertes lorsque le quota approche de sa limite

Garbage Collection

Le Garbage Collection supprime les artefacts orphelins (layers non référencés par des images) pour libérer de l'espace.

Déclenchement

• Manuel : via l'interface web (Administration → Garbage Collection → "GC Now")
• Planifié : configuration d'un cron pour exécution automatique (ex : tous les dimanches à 2h)

Bonnes pratiques de nettoyage

✅ Recommandé :

• Planifier un GC hebdomadaire automatique (nuit du samedi au dimanche)
• Supprimer régulièrement les tags obsolètes ou de développement
• Définir une politique de rétention (ex : garder les 10 dernières versions uniquement)
• Utiliser des tags explicites plutôt que latest pour faciliter le nettoyage

❌ À éviter :

• GC trop fréquents (impact sur les performances)
• Suppression d'images encore utilisées en production
• Absence de politique de rétention (croissance incontrôlée)

Réplication

La réplication permet de synchroniser des images entre plusieurs registries Harbor (ou vers d'autres registries OCI compatibles).

Cas d'usage

Configuration

1. Dans Administration → Replications, créez une règle de réplication
2. Définissez la source (local ou distant) et la destination
3. Configurez les filtres :
   • Projets spécifiques
   • Tags matchant un pattern (ex : v*, prod-*)
4. Définissez le déclencheur :
   • Manuel : déclenché manuellement
   • Scheduled : planification cron
   • Event Based : dès qu'une nouvelle image est poussée

Webhooks et automatisation

Harbor peut envoyer des webhooks lors d'événements spécifiques pour déclencher des actions automatisées.

Événements supportés

Configuration

1. Dans les paramètres du projet, allez dans "Webhooks"
2. Créez un webhook avec l'URL de destination
3. Sélectionnez les événements à surveiller
4. Harbor enverra une requête POST JSON à chaque événement

Exemple de payload webhook (push artifact)

{
  "type": "pushArtifact",
  "occur_at": 1708881234,
  "operator": "admin",
  "event_data": {
    "resources": [
      {
        "resource_url": "harbor.k8s-prod.sdv.fr/production/backend:1.2.3",
        "tag": "1.2.3"
      }
    ],
    "repository": {
      "name": "backend",
      "namespace": "production",
      "repo_full_name": "production/backend",
      "repo_type": "private"
    }
  }
}

Bonnes pratiques

Sécurité

✅ Recommandations :

• Utiliser des Robot Accounts pour les pipelines CI/CD plutôt que des comptes utilisateurs
• Activer le scan automatique de vulnérabilités sur tous les projets
• Mettre en place une politique de blocage des images critiquement vulnérables
• Ne jamais commiter de credentials Docker dans Git (utiliser .gitignore)
• Renouveler régulièrement les tokens des Robot Accounts
• Activer Content Trust (signature d'images) pour les environnements de production
• Limiter les droits des utilisateurs au strict nécessaire (principe du moindre privilège)

Gestion des images

✅ Recommandations :

• Utiliser des tags versionnés explicites (semantic versioning, git SHA)
• Éviter le tag latest en production
• Documenter les tags dans vos repositories (README, changelog)
• Implémenter une politique de rétention pour nettoyer les anciennes images
• Organiser les projets par environnement ou par équipe
• Utiliser des images de base minimales (alpine, distroless, scratch)
• Scanner régulièrement les anciennes images (nouvelles CVE)

Performance

✅ Recommandations :

• Planifier le Garbage Collection durant les heures creuses
• Planifier le Scan des Vulnérabilités durant les heures creuses ou au push d'un contenu
• Optimiser la taille des images (multi-stage builds, .dockerignore)
• Utiliser le cache de layers Docker dans les pipelines CI/CD
• Configurer la réplication pour distribuer la charge sur plusieurs registries
• Monitorer l'utilisation des quotas de stockage

Organisation

✅ Recommandations :

• Établir des conventions de nommage claires (projets, repositories, tags)
• Documenter l'architecture des projets Harbor dans votre documentation interne
• Former les équipes aux bonnes pratiques Docker et Harbor
• Mettre en place des notifications pour les événements critiques (quota atteint, CVE critique)

Cas d'usage courants

Déploiement d'une application microservices

# 1. Construire chaque service
docker build -t harbor.k8s-prod.sdv.fr/production/frontend:1.0.0 ./frontend
docker build -t harbor.k8s-prod.sdv.fr/production/backend:1.0.0 ./backend
docker build -t harbor.k8s-prod.sdv.fr/production/api:1.0.0 ./api
 
# 2. Pousser les images vers Harbor
docker push harbor.k8s-prod.sdv.fr/production/frontend:1.0.0
docker push harbor.k8s-prod.sdv.fr/production/backend:1.0.0
docker push harbor.k8s-prod.sdv.fr/production/api:1.0.0
 
# 3. Déployer sur Kubernetes
kubectl apply -f k8s/frontend-deployment.yaml
kubectl apply -f k8s/backend-deployment.yaml
kubectl apply -f k8s/api-deployment.yaml

Migration d'images depuis Docker Hub

# Pull depuis Docker Hub
docker pull nginx:1.24-alpine
 
# Retag pour Harbor
docker tag nginx:1.24-alpine harbor.k8s-prod.sdv.fr/shared-libs/nginx:1.24-alpine
 
# Push vers Harbor
docker push harbor.k8s-prod.sdv.fr/shared-libs/nginx:1.24-alpine

Promotion staging → production

# Pull depuis staging
docker pull harbor.k8s-prod.sdv.fr/staging/backend:2.0.0-rc1
 
# Retag pour production
docker tag harbor.k8s-prod.sdv.fr/staging/backend:2.0.0-rc1 \
           harbor.k8s-prod.sdv.fr/production/backend:2.0.0
 
# Push en production
docker push harbor.k8s-prod.sdv.fr/production/backend:2.0.0

Support et assistance

Pour toute question ou problème lié au registry Harbor :

• Documentation officielle Harbor : goharbor.io/docs
• Support technique SdV : contactez vos interlocuteurs habituels ou ouvrez un ticket
• Demande d'évolution : augmentation de quotas, activation LDAP/OIDC, configuration avancée