GitLab

Ce guide vous explique comment configurer l'authentification unique (SSO) entre SmartLink et GitLab. GitLab supporte à la fois OpenID Connect et SAML2 - nous recommandons OpenID Connect pour sa simplicité.

Prérequis

• GitLab CE/EE version 11.4+ (pour OpenID Connect)
• GitLab CE/EE version 9.0+ (pour SAML2)
• Accès administrateur à GitLab
• Application configurée dans SmartLink

Configuration avec OpenID Connect (Recommandé)

Configuration dans SmartLink

1. Créer l'application

1. Connectez-vous à SmartLink en tant qu'administrateur
2. Allez dans Applications → Ajouter
3. Créez une nouvelle application :
   • Nom : GitLab
   • URL : https://gitlab.example.com
   • Description : Plateforme DevOps GitLab
   • Icône : Choisissez l'icône GitLab

2. Configurer OpenID Connect

1. Dans l'onglet Authentification
2. Sélectionnez OpenID Connect
3. Notez les informations :
   • Client ID : gitlab-xxxxxx
   • Client Secret : secret-xxxxxx
   • Issuer URL : https://votre-smartlink.link.vaultys.org/api/oidc/[appid]
   • App ID : [appid] (identifiant unique de l'application dans SmartLink)

3. URLs de redirection

Ajoutez dans URLs de redirection autorisées :

https://gitlab.example.com/users/auth/openid_connect/callback

4. Scopes requis

• openid
• profile
• email
• groups (optionnel, pour la synchronisation des groupes)

Configuration dans GitLab

1. Configuration Omnibus (gitlab.rb)

Éditez /etc/gitlab/gitlab.rb :

### Configuration OpenID Connect avec SmartLink ###

gitlab_rails['omniauth_enabled'] = true
gitlab_rails['omniauth_allow_single_sign_on'] = ['openid_connect']
gitlab_rails['omniauth_sync_email_from_provider'] = 'openid_connect'
gitlab_rails['omniauth_sync_profile_from_provider'] = ['openid_connect']
gitlab_rails['omniauth_sync_profile_attributes'] = ['name', 'email']
gitlab_rails['omniauth_auto_sign_in_with_provider'] = 'openid_connect'
gitlab_rails['omniauth_block_auto_created_users'] = false
gitlab_rails['omniauth_auto_link_user'] = ['openid_connect']

gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect",
    label: "SmartLink SSO",
    icon: "https://votre-smartlink.example.com/logo.png",
    args: {
      name: "openid_connect",
      scope: ["openid", "profile", "email", "groups"],
      response_type: "code",
      issuer: "https://votre-smartlink.link.vaultys.org",
      discovery: true,
      discovery_endpoint: "https://votre-smartlink.link.vaultys.org/api/oidc/[appid]/.well-known/openid-configuration",
      client_auth_method: "query",
      uid_field: "sub",
      send_scope_to_token_endpoint: "false",
      pkce: true,
      client_options: {
        identifier: "gitlab-xxxxxx",
        secret: "secret-xxxxxx",
        redirect_uri: "https://gitlab.example.com/users/auth/openid_connect/callback"
      }
    }
  }
]

# Synchronisation des groupes (optionnel)
gitlab_rails['omniauth_external_providers'] = ['openid_connect']
gitlab_rails['omniauth_allow_bypass_two_factor'] = ['openid_connect']

2. Configuration Docker

Pour GitLab Docker, utilisez les variables d'environnement :

version: '3.8'
services:
  gitlab:
    image: gitlab/gitlab-ee:latest
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        gitlab_rails['omniauth_enabled'] = true
        gitlab_rails['omniauth_allow_single_sign_on'] = ['openid_connect']
        gitlab_rails['omniauth_auto_sign_in_with_provider'] = 'openid_connect'
        gitlab_rails['omniauth_providers'] = [
          {
            name: "openid_connect",
            label: "SmartLink SSO",
            args: {
              name: "openid_connect",
              scope: ["openid", "profile", "email"],
              response_type: "code",
              issuer: "https://votre-smartlink.link.vaultys.org",
              discovery: true,
              discovery_endpoint: "https://votre-smartlink.link.vaultys.org/api/oidc/[appid]/.well-known/openid-configuration",
              uid_field: "sub",
              client_options: {
                identifier: "${OIDC_CLIENT_ID}",
                secret: "${OIDC_CLIENT_SECRET}",
                redirect_uri: "https://gitlab.example.com/users/auth/openid_connect/callback"
              }
            }
          }
        ]

3. Appliquer la configuration

# Pour Omnibus
gitlab-ctl reconfigure
gitlab-ctl restart

# Pour Docker
docker-compose up -d

Synchronisation des groupes

Pour synchroniser automatiquement les groupes SmartLink avec GitLab :

# Dans gitlab.rb
gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect",
    args: {
      # ... configuration existante ...
      groups_attribute: "groups",
      admin_groups: ["smartlink_admins"],
      external_groups: ["smartlink_external"],
      required_groups: ["gitlab_users"]
    }
  }
]

Configuration avec SAML2

Configuration dans SmartLink

1. Configurer SAML2

1. Dans l'application GitLab
2. Onglet Authentification → SAML2
3. Configurez :
   • Entity ID : https://gitlab.example.com
   • ACS URL : https://gitlab.example.com/users/auth/saml/callback
   • Format NameID : emailAddress

2. Télécharger les métadonnées

Téléchargez ou notez :

• Métadonnées IdP : https://votre-smartlink.link.vaultys.org/api/saml2/[appid]/metadata
• Certificat X.509
• SSO URL : https://votre-smartlink.link.vaultys.org/api/saml2/[appid]/sso
• SLO URL : https://votre-smartlink.link.vaultys.org/api/saml2/[appid]/slo

Configuration dans GitLab

# Dans /etc/gitlab/gitlab.rb

gitlab_rails['omniauth_enabled'] = true
gitlab_rails['omniauth_allow_single_sign_on'] = ['saml']
gitlab_rails['omniauth_auto_sign_in_with_provider'] = 'saml'
gitlab_rails['omniauth_block_auto_created_users'] = false
gitlab_rails['omniauth_auto_link_saml_user'] = true

gitlab_rails['omniauth_providers'] = [
  {
    name: "saml",
    label: "SmartLink SSO",
    args: {
      assertion_consumer_service_url: "https://gitlab.example.com/users/auth/saml/callback",
      idp_cert: "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----",
      idp_sso_target_url: "https://votre-smartlink.link.vaultys.org/api/saml2/[appid]/sso",
      idp_metadata_url: "https://votre-smartlink.link.vaultys.org/api/saml2/[appid]/metadata",
      issuer: "https://gitlab.example.com",
      name_identifier_format: "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress",
      attribute_statements: {
        email: ['email'],
        name: ['name'],
        nickname: ['username'],
        groups: ['groups']
      }
    }
  }
]

Gestion des permissions

Mapping des rôles

Configurez le mapping automatique des rôles :

# OpenID Connect
gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect",
    args: {
      # Groupes d'administrateurs GitLab
      admin_groups: ["smartlink-gitlab-admins"],
      
      # Utilisateurs externes (accès limité)
      external_groups: ["smartlink-contractors"],
      
      # Groupes requis pour accéder
      required_groups: ["smartlink-gitlab-users"],
      
      # Groupes auditeurs (read-only)
      auditor_groups: ["smartlink-auditors"]
    }
  }
]

Auto-provisioning des projets

Pour créer automatiquement des projets basés sur les groupes :

# Script de provisioning personnalisé
gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect",
    args: {
      # ... configuration ...
      after_sign_in_path: proc do |user, groups|
        groups.each do |group|
          # Logique de création de projet/groupe
          Group.find_or_create_by(path: group) do |g|
            g.name = group
            g.add_user(user, :developer)
          end
        end
      end
    }
  }
]

Configuration des utilisateurs

Attribution automatique des licences (GitLab EE)

# Pour GitLab Enterprise Edition
gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect",
    args: {
      # ... configuration ...
      license_groups: {
        ultimate: ["smartlink-ultimate-users"],
        premium: ["smartlink-premium-users"],
        starter: ["smartlink-starter-users"]
      }
    }
  }
]

Configuration du profil utilisateur

# Synchronisation complète du profil
gitlab_rails['omniauth_sync_profile_from_provider'] = ['openid_connect']
gitlab_rails['omniauth_sync_profile_attributes'] = [
  'name',
  'email', 
  'location',
  'bio',
  'organization',
  'website_url'
]

Test de la configuration

1. Test de connexion

1. Déconnectez-vous de GitLab
2. Sur la page de connexion, cliquez sur SmartLink SSO
3. Authentifiez-vous sur SmartLink
4. Vérifiez la redirection vers GitLab

2. Vérification des permissions

# Via l'API GitLab
curl -H "PRIVATE-TOKEN: your_token" \
  "https://gitlab.example.com/api/v4/user"

# Via Rails console
gitlab-rails console
user = User.find_by_email('user@example.com')
user.identities
user.group_members

3. Test avec Git

# Cloner avec SSO
git clone https://gitlab.example.com/groupe/projet.git

# Si demandé, utilisez :
# Username: oauth2
# Password: [votre token d'accès personnel]

Dépannage

Erreur "Could not authenticate you from OpenIDConnect"

Solution :

1. Vérifiez les logs GitLab :

   gitlab-ctl tail gitlab-rails
2. Testez la découverte OIDC avec votre appid :

   curl https://votre-smartlink.link.vaultys.org/api/oidc/[appid]/.well-known/openid-configuration
3. Vérifiez le Client ID et Secret

Les groupes ne sont pas synchronisés

Solution :

1. Vérifiez le claim des groupes dans la réponse OIDC
2. Activez les logs détaillés :

   gitlab_rails['omniauth_providers'] = [
     {
       args: {
         client_options: {
           debug: true
         }
       }
     }
   ]

Erreur 422 après authentification

Solution :

1. Vérifiez que l'email est unique dans GitLab
2. Activez l'auto-link :

   gitlab_rails['omniauth_auto_link_user'] = ['openid_connect']

Utilisateurs bloqués après création

Solution :

# Désactiver le blocage automatique
gitlab_rails['omniauth_block_auto_created_users'] = false

# Ou débloquer manuellement
gitlab-rails console
User.where(state: 'blocked').update_all(state: 'active')

Sécurité

Recommandations

1. HTTPS obligatoire sur GitLab et SmartLink
2. Rotation des secrets régulière
3. Limitation des groupes avec required_groups
4. Audit logs activés :

   gitlab_rails['audit_events_enabled'] = true
5. 2FA bypass uniquement si SmartLink gère le MFA :

   gitlab_rails['omniauth_allow_bypass_two_factor'] = ['openid_connect']

Protection CSRF

# Protection contre les attaques CSRF
gitlab_rails['omniauth_providers'] = [
  {
    args: {
      pkce: true,  # Utiliser PKCE pour OpenID Connect
      state: true  # Vérifier le state parameter
    }
  }
]

Configuration avancée

Multi-instance GitLab

Pour plusieurs instances GitLab avec le même SmartLink :

# Instance production
gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect",
    args: {
      client_options: {
        identifier: "gitlab-prod-xxxxxx",
        redirect_uri: "https://gitlab.example.com/users/auth/openid_connect/callback"
      }
    }
  }
]

# Instance staging
gitlab_rails['omniauth_providers'] = [
  {
    name: "openid_connect", 
    args: {
      client_options: {
        identifier: "gitlab-staging-xxxxxx",
        redirect_uri: "https://gitlab-staging.example.com/users/auth/openid_connect/callback"
      }
    }
  }
]

Intégration CI/CD

Pour utiliser SSO dans les pipelines :

# .gitlab-ci.yml
variables:
  CI_JOB_TOKEN_SCOPE: "openid_connect"

deploy:
  script:
    - |
      TOKEN=$(curl -X POST https://votre-smartlink.link.vaultys.org/api/oidc/[appid]/token \
        -d "grant_type=client_credentials" \
        -d "client_id=${CI_CLIENT_ID}" \
        -d "client_secret=${CI_CLIENT_SECRET}")
    - # Utiliser $TOKEN pour les déploiements

Ressources

• Documentation GitLab OmniAuth
• GitLab OpenID Connect
• GitLab SAML
• Configuration SAML2 SmartLink