# Déployer votre premier service

> De l'application ouverte par Wakastart à un service en ligne sur son URL HTTPS, en sept étapes dans la console.

Ce démarrage rapide met en ligne un premier service de votre application, sans quitter la console. Vous reliez un dépôt Git, décrivez le service, créez un environnement, construisez l'image, la déployez, puis l'exposez sur une URL publique.

## Ce que vous allez construire

Un service **Frontend** construit depuis la branche `main` de votre dépôt, qui tourne dans un environnement de développement et répond en HTTPS sur une URL du type `https://www.monapp.<domaine plateforme>`.

Le parcours suit la règle de la plateforme : vous déclarez d'abord le service dans l'**architecture** de l'application, une seule fois ; chaque [environnement](/v1.0/glossaire#environnement) en reçoit ensuite sa propre [instance](/v1.0/glossaire#instance). La page [Définitions et instances](/v1.0/concepts/definitions-et-instances) explique ce principe.

## Avant de commencer

- [ ] Votre application apparaît dans le menu de la console. Votre application est créée par Wakastart ; contactez-nous pour en ouvrir une.
- [ ] Vous avez le profil **Infra** sur cette application : il ouvre les menus **Architecture**, **Builds** et **Environnements** et autorise les actions de ce parcours.
- [ ] Votre code est sur GitHub, avec un `Dockerfile` à la racine du dépôt (ou du dossier du service).
- [ ] L'application écoute en HTTP sur un port connu, par exemple `3000`.

::::steps
### Relier votre dépôt Git

1. Dans le menu latéral, sous le nom de votre application, cliquez sur **Architecture**, puis sur la carte **Repositories**.
2. Cliquez sur **Nouveau repository**.
3. Choisissez le type de dépôt :
   - pour un dépôt GitHub existant, désactivez **Repository managé**, puis saisissez son adresse dans **URL du repository**, au format `https://github.com/mon-org/mon-app.git` ;
   - pour que Wakastart crée un dépôt vierge pour vous, laissez **Repository managé** activé.
4. Saisissez le **Nom du repository**, en minuscules, chiffres et tirets, par exemple `mon-app`.
5. Vérifiez la **Branche par défaut** (`main`), puis cliquez sur **Créer**.

Résultat : le dépôt apparaît dans la liste. Un dépôt existant est prêt tout de suite ; un dépôt managé passe par `PENDING` le temps que Wakastart le crée.

:::important
Wakastart clone les dépôts existants avec son application GitHub. Elle doit être installée sur votre dépôt avant le premier build : demandez son nom à l'équipe Wakastart si ce n'est pas déjà fait.
:::

### Déclarer le service dans l'architecture

1. Dans **Architecture**, ouvrez **Services**, puis cliquez sur **Nouveau service**.
2. Dans **Informations de base**, saisissez le **Nom** (`web`), choisissez le **Rôle** **Frontend - Interface utilisateur web** et indiquez la **Technologie** (`nextjs`, par exemple).
3. Dans **Code source**, choisissez votre dépôt dans **Repository**. Pour un dépôt qui contient plusieurs services, indiquez le **Répertoire racine** du service. Laissez **Dockerfile** et **Contexte de build** à leurs valeurs si votre `Dockerfile` est à la racine.
4. Dans **Image Container**, gardez l'**Instance Harbor** marquée « (défaut) » et le **Projet Harbor** proposé.
5. Dans **Réseau par défaut**, gardez le **Protocole** **HTTP/HTTPS** et saisissez le **Port par défaut** de votre application (`3000`).
6. Cliquez sur **Créer le service**.

Résultat : le message « Service créé » s'affiche. Le service existe dans l'architecture, mais rien ne tourne encore.

### Créer l'environnement

1. Dans le menu latéral, sous le nom de l'application, cliquez sur **Environnements**, puis sur **Nouvel environnement**.
2. Saisissez le **Nom de l'instance** (`Développement`), choisissez le **Type d'environnement** **Development** et saisissez le **Nom court** `dev`.
3. Dans **Configuration Git**, laissez la **Référence Git** à `main`.
4. Cliquez sur **Créer l'environnement**.

Résultat : le message « Environnement créé » s'affiche et l'environnement apparaît dans la liste. Wakastart prépare en arrière-plan son espace d'exécution et son coffre de secrets.

### Construire l'image

1. Dans le menu latéral, cliquez sur **Builds**, puis sur **Nouveau build**.
2. Choisissez le **Service** `web`, le **Type de source** **Branche** et la **Branche** `main`.
3. Laissez **Mode Boost** coché : il alloue plus de ressources au build.
4. Cliquez sur **Déclencher le build**.

Résultat : la page **Build #…** s'ouvre et se met à jour seule. Le statut passe de **En attente** à **En cours**, puis à **Succès**. Les **Logs du build** s'affichent à la fin du build. L'image porte un tag de la forme `main-20261023-091244`.

### Déployer le service dans l'environnement

1. Dans **Environnements**, ouvrez l'environnement `dev`, puis l'onglet **Services**.
2. Cliquez sur **Déployer un service**.
3. Choisissez la **Définition de service** `web`, puis, dans **Image à déployer**, le tag construit à l'étape précédente.
4. Laissez le **Nombre de réplicas** à `1`, puis cliquez sur **Déployer le service**.

Résultat : l'instance apparaît dans **Instances de services** avec le statut **En attente**, puis **Provisionnement...**, puis **Provisionné** quand les conteneurs ont démarré. L'onglet **Deployments** garde la trace de ce premier déploiement.

### Exposer le service sur une URL

1. Dans **Architecture**, ouvrez **URLs**, puis cliquez sur **Nouvelle URL**.
2. Saisissez le **Sous-domaine** `www`, choisissez un **Domaine** dans le groupe des domaines plateforme, puis cliquez sur **Créer**. L'aperçu affiche le nom complet, par exemple `www.monapp.<domaine plateforme>`.
3. Sur la carte de l'URL, cliquez sur **Ajouter une route**. Laissez le **Chemin** à `/` et le **Type de chemin** à `PathPrefix`, choisissez le **Service** `web`, cochez **URL front officielle de l'app**, puis validez.
4. Ouvrez l'environnement `dev`, onglet **URLs & IAM**. Dans **Routes d'architecture manquantes dans l'environnement**, cliquez sur **Instancier** en face de votre route.

Résultat : la route rejoint les routes actives de l'environnement. Wakastart crée l'enregistrement DNS et demande un certificat TLS pour ce nom d'hôte.

### Vérifier que ça marche

1. Dans l'onglet **URLs & IAM**, attendez que la colonne **STATUS** de la route affiche `PROVISIONED` : le certificat et le DNS sont prêts. Comptez quelques minutes ; aucun délai n'est garanti.
2. Ouvrez `https://www.monapp.<domaine plateforme>` dans un navigateur.

Résultat attendu : votre application répond en HTTPS. Une requête en `http://` est redirigée vers `https://`.

Dans l'onglet **Résumé** de l'environnement, l'encart **Ce qu'il reste à configurer** liste ce qui manque encore pour que l'environnement soit complet : variables sans valeur, bases non provisionnées, services sans build.
::::

## Et ensuite

- **Livrer à chaque push** : dans le **Résumé** de l'environnement, le bouton **Éditer** de **Configuration Git** active le **Build automatique** et l'option **Auto-deploy on new build** sur la branche suivie.
- **Revenir à une version précédente** : dans l'instance du service, **Déployer** propose les images déjà construites ; choisissez un tag plus ancien.
- **Fournir la configuration** : déclarez les variables attendues du service, puis donnez-leur une valeur dans l'onglet **Configuration** de chaque environnement.

## Étapes suivantes

::::cards{cols=3}
:::card{title="Définitions et instances" href="/v1.0/concepts/definitions-et-instances" icon="Layers"}
Pourquoi le service existe deux fois, et comment les valeurs par défaut se propagent.
:::
:::card{title="Builds et déploiements" href="/v1.0/builds-et-deploiements" icon="Hammer"}
Builds automatiques, historique des déploiements, retour arrière.
:::
:::card{title="Variables et secrets" href="/v1.0/variables-et-secrets" icon="Lock"}
Donner à chaque environnement ses valeurs, sans exposer un secret.
:::
::::
