Déployer votre première application

Ce tutoriel vous guidera à travers les étapes pour déployer votre première application sur la plateforme Atlas.

Prérequis

• Avoir un compte sur la plateforme Atlas
• Être administrateur de workspace ou avoir les droits nécessaires
• Avoir un workspace déjà créé (voir Créer votre premier workspace)
• Avoir accès au dépôt GitOps de votre workspace

Vue d'ensemble

Pour déployer une application sur Atlas, vous devez :

1. Créer un DeploymentTarget (Deployment Target)
2. Ajouter vos manifestes Kubernetes dans le dossier dédié au DeploymentTarget

Étapes pour déployer une application

1. Cloner le dépôt GitOps de votre workspace

1
2

git clone <URL du dépôt de votre workspace>
cd <nom du dépôt>

2. Créer un DeploymentTarget

Créez un nouveau fichier YAML dans le dossier resources du dépôt. Nommez-le de manière significative, par exemple mon-app-dev.yaml.

1
2

mkdir -p resources
touch resources/mon-app-dev.yaml

Ouvrez le fichier mon-app-dev.yaml dans votre éditeur préféré et ajoutez la configuration suivante :

1
2
3
4
5
6
7
8
9

apiVersion: workspace.fabrique.social.gouv.fr/v1alpha1
kind: DeploymentTarget
metadata:
  name: mon-app-dev
spec:
  parameters:
    name: "mon-app-dev"
    zoneRef:
      name: "dev"

Assurez-vous de remplacer mon-app-dev par un nom significatif pour votre environnement de déploiement et dev par le nom de la zone appropriée (par exemple, dev, prod).

3. Créer le dossier pour les manifestes de l'application

1

mkdir -p deployment-targets/mon-app-dev

4. Ajouter les manifestes Kubernetes

Créez les fichiers YAML nécessaires pour votre application dans le dossier deployment-targets/mon-app-dev. Par exemple, pour déployer une application web simple :

1
2
3

touch deployment-targets/mon-app-dev/deployment.yaml
touch deployment-targets/mon-app-dev/service.yaml
touch deployment-targets/mon-app-dev/ingress.yaml

Exemple de deployment.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-application
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mon-application
  template:
    metadata:
      labels:
        app: mon-application
    spec:
      containers:
      - name: mon-application
        image: nginx:latest
        ports:
        - containerPort: 80

Exemple de service.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

apiVersion: v1
kind: Service
metadata:
  name: mon-application
spec:
  selector:
    app: mon-application
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

Exemple de ingress.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-application
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: mon-application.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: mon-application
            port:
              number: 80

5. Pousser les changements vers le dépôt

1
2
3
4

git add resources/mon-app-dev.yaml
git add deployment-targets/mon-app-dev/
git commit -m "Ajout du DeploymentTarget et des manifestes pour mon-application"
git push

6. Vérifier le déploiement

Une fois les changements poussés, ArgoCD détectera automatiquement les modifications et déploiera votre application. Vous pouvez vérifier l'état du déploiement dans ArgoCD.

1. Accédez à ArgoCD via l'interface Atlas
2. Recherchez l'application correspondant à votre DeploymentTarget
3. Vérifiez que les ressources ont été déployées avec succès

Utilisation de Helm Charts (Optionnel)

Si vous préférez utiliser Helm pour gérer vos déploiements, vous pouvez spécifier des charts dans la définition du DeploymentTarget. Notez que cette fonctionnalité est expérimentale.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

apiVersion: workspace.fabrique.social.gouv.fr/v1alpha1
kind: DeploymentTarget
metadata:
  name: mon-app-dev
spec:
  parameters:
    name: "mon-app-dev"
    zoneRef:
      name: "dev"
    charts:
      - chart: "nginx"
        releaseName: "mon-nginx"
        repoURL: "https://charts.bitnami.com/bitnami"
        version: "19.0.0"
        values: {}

Cependant, il est recommandé d'utiliser le rendered manifest pattern et de pousser la sortie d'un "helm template" dans le dépôt GitOps.

Que faire ensuite ?

Maintenant que vous avez déployé votre application, vous pouvez :

• Configurer une base de données pour stocker les données de votre application
• Utiliser un bucket S3 pour stocker des fichiers
• Configurer des secrets pour votre application

Résolution des problèmes courants

L'application n'apparaît pas dans ArgoCD

• Vérifiez que vous avez bien poussé les changements vers le dépôt
• Vérifiez que les fichiers YAML sont correctement formatés
• Vérifiez que vous avez les droits nécessaires

Erreur lors du déploiement

• Vérifiez les logs dans ArgoCD pour identifier l'erreur
• Assurez-vous que les ressources sont correctement définies
• Vérifiez que les images Docker sont accessibles
• Contactez l'administrateur de la plateforme si le problème persiste