Dans l’écosystème Cloud et DevOps, ArgoCD est un outil incontournable pour implémenter le modèle GitOps, qui utilise des référentiels Git pour déployer des applications sur des clusters Kubernetes. L’une des fonctionnalités d’ArgoCD, le générateur scmProvider, facilite davantage la gestion et l’automatisation des déploiements GitOps.
Dans cet article, nous allons explorer ce qu’est le SCM Provider Generator, pourquoi il est utile, et comment l’utiliser efficacement.
Qu’est-ce qu’un SCM ?
Un SCM (Source Control Management ou gestionnaire de contrôle de source) est un système permettant de gérer les versions et l'historique des fichiers dans un projet. Cela inclut la gestion des modifications de code source, des configurations et d'autres fichiers critiques. Par exemple, GitLab est un SCM populaire.
En connectant ArgoCD à un SCM comme GitLab, vous pouvez automatiser le déploiement de vos applications Kubernetes basées sur les modifications apportées dans vos dépôts.
Qu’est-ce qu’un generator ArgoCD ?
Dans ArgoCD, les generators sont des outils qui génèrent automatiquement des paramètres et les remplacent dans un template pour configurer dynamiquement des applications. Par exemple, ils peuvent s’appuyer sur une liste prédéfinie pour cibler des clusters spécifiques, ou encore utiliser un dépôt Git pour structurer les déploiements en fonction des fichiers ou des répertoires qu'il contient. D’autres générateurs plus avancés peuvent détecter automatiquement les pull requests ouvertes dans un projet ou combiner plusieurs sources de données pour produire des configurations complexes. Ces mécanismes rendent les déploiements plus dynamiques et adaptables aux besoins variés d’un environnement Kubernetes.
Qu’est-ce que le SCM Provider Generator ?
Le SCM Provider Generator est un generator qui permet à ArgoCD de découvrir automatiquement les applications à gérer à partir des répertoires Git. Cette fonctionnalité s’intègre avec des plateformes SCM populaires comme GitHub, GitLab, Bitbucket ou Azure DevOps.
Au lieu de devoir définir manuellement chaque application que vous souhaitez déployer dans les configurations d’ArgoCD, vous pouvez configurer le generator scmProvider pour qu’il recherche des répertoires présents dans un groupe gtilab ou une organisation github. Vous pouvez également faire en sorte qu’il recherche des répertoires correspondant à des critères spécifiques (noms, labels, etc.) et déploie automatiquement les applications.
Pourquoi utiliser le SCM Provider Generator ?
Le SCM Provider Generator révolutionne la gestion des déploiements en automatisant et en simplifiant les processus à grande échelle. Grâce à cet outil, il n’est plus nécessaire de maintenir manuellement une liste d’applications dans la configuration d’ArgoCD. Vous pouvez désormais définir des critères globaux pour créer ou mettre à jour dynamiquement vos applications, ce qui améliore l’efficacité et réduit les tâches répétitives.
Cette solution s’avère particulièrement précieuse pour les organisations gérant un grand nombre d’applications et de répertoires Git. Elle permet de découvrir automatiquement tous les projets d’un groupe GitLab ou d’une organisation GitHub afin de déployer les applications qu'elle explore dans ce groupe ou cette organisation, rendant ainsi la gestion des déploiements plus simple.
Outre le SCM Provider Generator, une seconde approche ayant quelques ressemblances est le modèle 'App of Apps'. Ce modèle repose sur une application parent, configurée dans ArgoCD, qui référence et gère plusieurs applications enfants via leurs manifestes définis dans un dépôt Git. Chaque application enfant est elle-même une instance d’Application ArgoCD, permettant ainsi de gérer des groupes d’applications de manière modulaire et indépendante. Contrairement au SCM Provider Generator, qui utilise des critères globaux pour explorer automatiquement les dépôts Git et générer des applications, le modèle 'App of Apps' s’appuie sur une structure explicitement définie par l'administrateur.
En plus de ces solutions, ArgoCD propose également le Git Generator, un générateur permettant de gérer les applications directement à partir d’un seul dépôt Git spécifique. Contrairement au SCM Provider Generator, qui explore plusieurs dépôts d’une organisation ou d'un groupe, le Git Generator se concentre sur un dépôt unique en générant des applications à partir des répertoires ou fichiers qu’il contient. Cette approche convient mieux aux projets mono-repo ou aux configurations spécifiques nécessitant un contrôle plus granulaire.
Enfin, le SCM Provider Generator offre une grande flexibilité en permettant de filtrer les dépôts à inclure selon des critères spécifiques. Cela garantit une adaptabilité optimale aux besoins variés des équipes et des projets, tout en assurant un contrôle précis sur les configurations de déploiement.
Comment fonctionne le SCM Provider Generator ?
Le SCM Provider Generator est une extension puissante d’ArgoCD, qui travaille en collaboration avec des fonctionnalités essentielles comme AppProject et ApplicationSet pour automatiser la gestion des déploiements.
- L’AppProject est un regroupement logique d’applications dans ArgoCD. Il agit comme un cadre de gouvernance, en définissant des restrictions sur les clusters, les dépôts Git, et les namespaces autorisés pour les applications qu’il englobe. Cela permet de segmenter les applications selon les besoins organisationnels tout en maintenant un haut niveau de sécurité et de contrôle.
- L’ApplicationSet est une fonctionnalité clé d’ArgoCD qui facilite la gestion d’un ensemble d’applications à partir d’une configuration centralisée. Plutôt que de définir manuellement chaque application, l’ApplicationSet permet de gérer plusieurs applications à travers un modèle unique.
- Le SCM Provider Generator est un type de générateur pour les ApplicationSet. Il se connecte aux plateformes Git via leurs API (comme l’API GitLab ou GitHub) pour interagir avec le SCM. Voici comment il fonctionne :
- Découverte des dépôts : Le générateur utilise les API SCM pour répertorier les dépôts disponibles au sein d’un groupe GitLab ou d’une organisation GitHub. Cette découverte est automatique et peut être affinée selon des critères prédéfinis.
- Extraction des métadonnées : Il extrait des informations pertinentes sur les dépôts, telles que les branches disponibles, les labels, ou d’autres métadonnées utiles pour la configuration des applications.
- Création d’applications dynamiques : À partir des données collectées, le générateur applique des modèles prédéfinis pour créer automatiquement des applications ArgoCD. Ces modèles peuvent inclure des configurations spécifiques à chaque répertoire, comme des branches ou des environnements ciblés.
Grâce à cette architecture, le SCM Provider Generator allie automatisation, centralisation, et flexibilité, ce qui le rend particulièrement adapté pour les environnements avec de nombreux répertoires ou projets. En collaborant étroitement avec les AppProjects et ApplicationSets, il garantit une gestion simplifiée et cohérente des déploiements, même dans des infrastructures complexes ou distribuées.
Implication de l’utilisation de SCM Provider Generator
L’utilisation de SCM Provider Generator dans Argo CD demande une vigilance accrue en matière de sécurité. Déployer des applications Kubernetes à partir de dépôts Git implique de protéger strictement l’accès à ces derniers.
Il est fortement conseillé de limiter la création des ApplicationSets aux administrateurs, afin de prévenir tout risque de déploiement non autorisé. De même, seuls les administrateurs devraient être habilités à créer ou gérer les dépôts Git et leurs branches, afin d’éviter toute gestion de ressources en dehors du périmètre prévu.
En somme, l’utilisation de SCM Provider Generator nécessite une gestion rigoureuse des permissions et une sécurisation renforcée des dépôts Git pour garantir la sécurité et l’intégrité des déploiements Kubernetes.
Exemple pratique : SCM Provider Generator
Prérequis:
- Cluster Kubernetes (par exemple minikube)
- ArgoCD > 2.8
- GitLab
Voici un exemple pratique d’utilisation du SCM Provider Generator avec GitLab. Les noms utilisés peuvent être modifiés selon vos préférences.
Voici à quoi ressemble l’architecture du notre groupe gitlab :
scm-mherville/ # group gitlab
├── scm/ # project scm
│ └── app/
│ └── scm.yaml
├── all-apps/ # subgroup all-apps
│ └── keda/ # project keda
│ ├── values-default.yaml
│ └── app/
└── └── keda.yamlTout d'abord, il est nécessaire de créer un groupe GitLab qui regroupe à la fois le répertoire SCM et un sous-groupe qui contiendra les applications que vous souhaitez déployer.
Une fois le groupe créé, vous devrez ensuite créer un projet qui contiendra l'ApplicationSet de votre SCM.
Ensuite, vous devrez créer un sous-groupe nommé "all-apps", qui contiendra toutes les applications que vous souhaitez déployer sur ArgoCD et dans votre cluster Kubernetes.
Récupérez l'ID du groupe que vous avez créé, car vous en aurez besoin par la suite. Vous devrez remplacer la valeur [ID_GROUP] dans les prochains fichiers yaml.
Dans un premier temps, nous allons configurer le SCM. Pour cela, créez un répertoire app dans le projet SCM que vous avez précédemment créé, puis ajoutez-y un fichier scm.yaml. Remplacez la valeur [URL_GROUP] par l’URL correspondant au groupe, que vous avez créé précédemment, destiné à accueillir toutes les applications que vous souhaitez déployer. Par exemple, dans mon cas, [URL_GROUP] sera remplacé par “https://gitlab.com/scm-mherville/all-apps”. Cela s’explique par le fait que j’ai créé un groupe nommé “scm-mherville”, au sein duquel j’ai défini un sous-groupe “all-apps” pour contenir les applications que je prévois de déployer.
#app/scm.yaml
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
namespace: argocd
name: scm
spec:
generators:
- scmProvider:
cloneProtocol: https
gitlab:
group: "[ID_GROUP]"
api: https://gitlab.com/
# If true, scan every branch of every repository. If false, scan only the default branch. Defaults to false
allBranches: false
# If true, recurses through subgroups. If false, it searches only in the base group. Defaults to false.
includeSubgroups: true
# Reference to a Secret containing an access token.
tokenRef:
secretName: gitlab-token
key: token
insecure: true
template:
metadata:
name: '{{ repository }}-scm'
spec:
project: "default"
source:
repoURL: "[URL_GROUP]/{{ repository }}.git"
targetRevision: 'main'
path: app/
destination:
server: https://kubernetes.default.svc
namespace: default
Ce fichier YAML permet de créer un ApplicationSet SCM qui scannera les répertoires présents dans le groupe ayant l'ID "[ID_GROUP]" et générera automatiquement des applications ArgoCD.
Une fois votre commit effectué, vous devrez créer un secret nommé "gitlab-token" dans le namespace argocd pour permettre au SCM de scanner vos répertoires GitLab, le token gitlab devra être créé en amont depuis l’interface Gitlab.
kubectl create secret generic gitlab-token --from-literal=token='[VOTRE_GITLAB_TOKEN]' -n argocdEnsuite, allez dans l'interface d'ArgoCD pour connecter votre répertoire SCM.
Cliquez sur “Settings”, “Connect Repo”, puis renseignez les valeurs azenécessaires et cliquez sur “Connect”. Pour la partie “Password”, renseigné votre [VOTRE_GITLAB_TOKEN]
Vous devez également créer un template pour les credentials.
Cliquer sur “save as credentials template”.
Ensuite, vous devez créer une application. Voici un fichier yaml permettant de créer l’application scm sur argocd, la valeur de repoURL doit être remplacée par l’url HTTPS vers votre répertoire gitlab contenant le code scm.
#app_scm.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: scm
namespace: argocd
spec:
project: default
source:
repoURL: https://gitlab.com/scm-mherville/scm.git
targetRevision: HEAD
path: app
destination:
server: https://kubernetes.default.svc
namespace: default
syncPolicy:
automated: nullVous devez ensuite appliquer ce fichier yaml dans votre cluster kubernetes :
kubectl apply -f app_scm.yaml -n argocdVotre application SCM est presque prête à déployer des applications. Il vous reste maintenant à créer les ApplicationSet pour les applications que vous souhaitez déployer.
La deuxième étape consiste à créer les répertoires des applications que vous souhaitez déployer dans le groupe "all-apps" que vous avez créé précédemment. Pour cette démonstration, je vais installer l'application Keda, un auto-scaler Kubernetes que je trouve intéressant.
Pour ce faire, créez un projet "keda" dans le groupe "all-apps" que vous avez précédemment créé. Ensuite, créez un fichier app/keda.yaml et un fichier values-[env_name].yaml à la racine de votre projet. Dans cet exemple, l'environnement étant "default", le fichier values s'appellera "values-default.yaml".
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
name: keda
namespace: argocd
spec:
goTemplate: true
generators:
- list:
elements:
- cluster: in-cluster
environment: default
project: default
namespace: keda
branche: main
versionchart: 2.15.2
nameApp: keda
template:
metadata:
name: '{{ .nameApp }}-{{ .project }}'
spec:
project: '{{ .project }}'
syncPolicy:
automated:
prune: true
allowEmpty: true
selfHeal: true
syncOptions:
- ServerSideApply=true
- CreateNamespace=true
sources:
- chart: keda
repoURL: https://kedacore.github.io/charts
targetRevision: "{{ .versionchart }}"
helm:
valueFiles:
- $valuesRef/values-{{ .environment }}.yaml
- repoURL: [URL_GROUP]/{{ .nameApp }}.git
targetRevision: "{{ .branche }}"
ref: valuesRef
destination:
server: https://kubernetes.default.svc
namespace: '{{ .namespace }}'Pour le fichier values-[env_name].yaml, vous pouvez y spécifier les valeurs souhaitées pour votre chart Helm. Une fois le commit réalisé, retournez dans l'interface ArgoCD pour synchroniser l'application SCM, puis synchronisez l'application keda-scm qui a été créée.
Une fois la synchronisation effectuée, une application keda-[env_name] sera créée et déployée dans votre cluster Kubernetes.
Le namespace de votre application est créé automatiquement, et l'application est déployée dans ce namespace sur votre cluster Kubernetes.
L’utilisation du SCM Provider Generator simplifie les déploiements Kubernetes, tandis que l’utilisation de goTemplate et de spec.generators.list.elements permet de gérer facilement les déploiements multi-environnements et multi-clusters. Par exemple, pour déployer Keda dans les environnements default et production, ainsi que sur le cluster prod-cluster, nous pouvons templatiser le fichier keda.yaml de la manière suivante :
spec:
goTemplate: true
generators:
- list:
elements:
- cluster: in-cluster
environment: default
project: default
namespace: keda
branche: main
versionchart: 2.15.2
nameApp: keda
- cluster: prod-cluster
environment: production
project: production
namespace: keda
branche: main
versionchart: 2.15.2
nameApp: kedaUtilisation de templatePatch pour plus de personnalisation
Le templatePatch est une fonctionnalité d'ArgoCD qui permet de modifier dynamiquement la configuration d'une application générée par un ApplicationSet. Il agit comme une couche supplémentaire de personnalisation, permettant d'appliquer des modifications conditionnelles ou spécifiques sans altérer directement le modèle principal.
Un templatePatch est défini sous forme d'un bloc YAML contenant des instructions conditionnelles. Ces instructions permettent d'activer ou désactiver certains paramètres en fonction de variables ou de conditions spécifiées dans le générateur.
spec:
generators:
- list:
elements:
- cluster: in-cluster
autoSync: true
...
template:
...
templatePatch: |
spec:
{{- if .autoSync }}
syncPolicy:
automated:
prune: true
{{- end }}
La partie templatePatch ci-dessus permet de dire que si nous avons défini une variable autoSync alors nous allons ajouter la partie spec.syncPolicy.automated.prune au template principal.
Avec templatePatch, vous pouvez facilement adapter les configurations aux exigences de vos environnements ou de vos applications sans complexifier la gestion des modèles.
Conclusion
Dans #ArgoCD, le scmProvider generator est une fonctionnalité puissante qui réduit le travail manuel et améliore la scalabilité des opérations #GitOps. En automatisant la découverte d’applications à partir de plateformes SCM populaires, il simplifie la gestion des déploiements #Cloud dans des environnements #Kubernetes.
Pour en tirer le meilleur parti, il est important de bien sécuriser les droits d’accès aux répertoires Git, de sécuriser l'accès à l'API en utilisant des tokens avec des droits minimums et de définir des critères de filtrage précis pour inclure uniquement les dépôts pertinents. Que vous gériez quelques applications ou des centaines, cette fonctionnalité permet de gagner un temps précieux.
Cette approche s’inscrit également dans une évolution plus large des capacités d’ArgoCD, en étendant le modèle 'App of Apps' grâce aux ApplicationSets et aux générateurs comme le scmProvider. Là où le modèle 'App of Apps' repose sur une structure définie par l’utilisateur pour organiser et gérer les applications, les générateurs ajoutent une couche d’automatisation puissante qui permet d’aller encore plus loin en déployant automatiquement des applications à partir de critères globaux. Ensemble, ces outils offrent une flexibilité et une efficacité accrues pour répondre aux défis des déploiements dans des environnements modernes.
