¶ Préparation du serveur
On va partir du mini-LAB, en adaptant la configuration matérielle du serveur debian Core, selon les prérequis pour installer un serveur GitLab :
- CPU : 4 cœurs.
- RAM : 4 Go minimum (8 Go recommandé pour des performances optimales).
- Disque : 10 Go minimum pour l'application, davantage si vous utilisez CI/CD.
Préparons le serveur debian-core :
- On s'y connecte en SSH depuis debian-gui (après avoir repéré son adresse IP)
- On modifie le hostname en gitlab :
sudo nano /etc/hostname
- sans oublier de modifier aussi le fichier hosts :
sudo nano /etc/hosts
qui doit au final ressembler à ceci :
127.0.0.1 localhost
127.0.1.1 gitlab
# The following lines are desirable for IPv6 capable hosts
::1 localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
- on fixe l’adresse IPv4 du serveur sur son unique interface :
sudo nano /etc/network/interfaces
Sur l'interface enp0s3 (lignes 11 et 12) : ip fixe 192.168.1.10/24 (ligne 13) et la passerelle 192.168.1.1 (ligne 14) :
# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
source /etc/network/interfaces.d/*
# The loopback network interface
auto lo
iface lo inet loopback
# The primary network interface
allow-hotplug enp0s3
iface enp0s3 inet static
address 192.168.1.10/24
gateway 192.168.1.1
- on redémarre le serveur :
sudo reboot
Puis, une fois le serveur relancé, on s'y connecte en ssh depuis le poste client :
ssh pascal@192.168.1.10
¶ Installation
- mise à jour système :
sudo apt update && sudo apt upgrade -y
- dépendances :
sudo apt install -y curl openssh-server ca-certificates tzdata perl
- ajouter depôt Gitlab :
curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash
- mise à jour des dépôts (préventif, car le script précédent le fait en principe) :
sudo apt update
- installer :
sudo GITLAB_ROOT_PASSWORD="password" EXTERNAL_URL="http://192.168.1.10" apt install gitlab-ce
- configurer et lancer gitlab :
sudo gitlab-ctl reconfigure
¶ Configuration de base après installation
Accès web : Rendez-vous sur http://192.168.1.10 dans un navigateur.
Définissez le mot de passe administrateur lors de la première connexion.
L’utilisateur par défaut est root.
- deactivate new sign ups if public users aren't expected
En cas de besoin le mot de passe est dans
/etc/gitlab/initial_root_password
¶ Activer HTTPS (optionnel)
Pour mémoire le process pour installer un certificat SSL avec Let's Encrypt :
sudo nano /etc/gitlab/gitlab.rb
- Ajoutez ou modifiez :
external_url "https://gitlab.example.com"
letsencrypt['enable'] = true
- Appliquez la configuration :
sudo gitlab-ctl reconfigure
¶ Gestion et maintenance
- Commandes utiles :
- Redémarrer GitLab :
sudo gitlab-ctl restart
- Consulter les logs :
sudo gitlab-ctl tail
- Mise à jour GitLab :
sudo apt update && sudo apt upgrade
¶ Sécurisation et optimisation
- créer d'autres utilisateurs (dont un administrateur autre que root)
- pour notre contexte, on peut exceptionnellemen rester en *root
- Sauvegardes automatiques : Configurez la sauvegarde dans
/etc/gitlab/gitlab.rb:
gitlab_rails['backup_path'] = "/var/opt/gitlab/backups"
gitlab_rails['backup_keep_time'] = 604800 # Garder 7 jours de sauvegardes
- Lancez une sauvegarde manuelle :
sudo gitlab-backup create
- restaurer :
sudo gitlab-backup restore BACKUP=<nom-du-fichier-de-sauvegarde>
¶ Projet 1
-
Créer le projet test-app sur gitlab
- blank project
- l'url est http://192.168.1.10/root/test-app
- visibility : private
- initialiser avec un README file
-
Ajouter une clé ssh pour l'authentification.
- Comme pour GitHub, créer une paire de clés SSH (RSA ou ed25519, on prendra ici le second) :
ssh-keygen -t ed25519 -b 4096 -C "adresse@email.com"- Récuperer la clé publique :
cat ~/.ssh/id_ed25519.pub- copier le texte de la clé publique et et ajouter une clé
sshsur GitLab
-
installer le package git sur le client à l’aide du gestionnaire de paquets :
sudo apt update && sudo apt upgrade && sudo apt install -y git -
On vérifie l'installation et la version de git :
git --version
Une fois installé, configurez Git avec vos informations personnelles :
git config --global user.name "Prénom NOM"
git config --global user.email "adresse@email.com"
git config --list
- puis cloner localement le projet :
git clone git@192.168.1.10:root/test-app.git
Voici la structure du projet que nous voulons créer :
test-app/
├── .gitlab-ci.yml
├── README.md
On se positionne :
cd test-app
Pour s'échauffer, on peut modifier le fichier README.md:
nano README.md
Personnalisez le fichier, et "poussez" cette première modif :
git add .
git commit -m "Modification du fichier README"
git push -u origin main
Créez un fichier .gitlab-ci.yml à la racine de votre projet :
nano .gitlab-ci.yml
avec ce contenu :
stages:
- build
- test
build-job:
stage: build
script:
- echo "Construction de l'application"
test-job:
stage: test
script:
- echo "Lancement des tests"
Poussez ce fichier dans votre dépôt.
GitLab exécutera les pipelines automatiquement après chaque push.
¶ installer le runner
Sur le client :
sudo apt install -y curl
curl -L "https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh" | sudo bash
sudo apt install gitlab-runner
(installer docker-ce avant ?)
Créer le runner (shell) sur le webadmin de gitlab et l'activer (et vérifier)
- settings > ci/cd > runner > new project runner
- run untagged
- linux
On récupère une commande (script) de ce type :
gitlab-runner register --url http://192.168.1.10 --token glrt-t3_m31fGKmfvZ1z-1zfzQoJ
qui permet d'enregistrer le runner > successfully
sudo gitlab-runner start
Les commandes echo du premier exemple vont sortir dans les logs du GitLab Runner, c'est-à-dire qu'elles seront affichées dans l'interface de GitLab lorsqu'on consulte les résultats du pipeline.
Où trouver les logs des commandes echo ?
- Projet GitLab
- dans "CI / CD" (dans le menu de gauche sous "Project").
- cliquer sur le pipeline en cours ou terminé
- Cliquer sur le job (par exemple, build-job ou test-job).
Dans les logs du job, on verra les résultats de toutes les commandes exécutées dans le script, y compris les echo qui affichent des messages comme :
Construction de l'application
Les fichiers de l'application ont été construits
Pour les voir sur le runner, on peut rediriger la sortie standard de echo.
¶ Projet 2 (en cours)
-
Créer le projet my-php-app sur gitlab
-
créer la connexion ssh (par clé)
-
puis cloner localement le projet :
git clone git@192.168.1.10:root/my-php-app.git
Voici la structure du projet que nous voulons créer :
my-php-app/
├── docker-compose.yml
├── docker-compose.staging.yml
├── src/
│ └── index.php
├── db/
│ └── init.sql
├── Dockerfile
├── .gitlab-ci.yml
├── README.md
On se positionne :
cd my-php-app
Fichier : src/index.php
<?php
$host = getenv('DB_HOST');
$db = getenv('DB_NAME');
$user = getenv('DB_USER');
$password = getenv('DB_PASSWORD');
try {
$pdo = new PDO("pgsql:host=$host;dbname=$db", $user, $password);
echo "Connexion réussie à la base de données !";
} catch (PDOException $e) {
echo "Erreur : " . $e->getMessage();
}
?>
Fichier : db/init.sql
Ce script permet d'initialiser la base de données avec des données exemple.
CREATE TABLE IF NOT EXISTS users (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL
);
INSERT INTO users (name) VALUES ('Alice'), ('Bob');
Fichier : Dockerfile
Pour construire l'image de l'application php
# Utiliser une image PHP avec Apache
FROM php:8.2-apache
# Activer les extensions PHP nécessaires
RUN docker-php-ext-install pdo pdo_pgsql
# Copier les fichiers du projet
COPY src/ /var/www/html/
Fichier : docker-compose.yml
services:
web:
build:
context: .
dockerfile: Dockerfile
ports:
- "8080:80"
environment:
DB_HOST: db
DB_NAME: appdb
DB_USER: user
DB_PASSWORD: password
depends_on:
- db
db:
image: postgres:15
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: password
POSTGRES_DB: appdb
volumes:
- ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
Fichier : .gitlab-ci.yml
Voici un pipeline pour construire, tester et déployer l'application directement en production.
image: docker:latest
services:
- docker:dind
variables:
DOCKER_HOST: tcp://docker:2375
DOCKER_DRIVER: overlay2
stages:
- build
- test
- deploy-production
build:
stage: build
script:
- docker-compose -f docker-compose.yml build
test:
stage: test
script:
- docker-compose -f docker-compose.yml up -d
- curl -f http://localhost:8080 || exit 1
- docker-compose down
deploy-production:
stage: deploy
script:
- docker-compose -f docker-compose.yml up -d
environment:
name: production
url: http://example.com
only:
- main # Déployer uniquement à partir de la branche "main"
Synchronisation du projet
git add .
git commit -m "Depôt initial"
git push -u origin main
???
- Configurez les variables d'environnement dans GitLab :
- Accédez à Settings > CI/CD > Variables. Ajoutez les variables pour laproduction :
DB_PASSWORD_PRODUCTION = password
???