Vous êtes ici : Accueil / Debian GNU/Linux / Serveurs / Développement / Installer GitLab sur Debian

Installer GitLab sur Debian

Par Pierre-Yves Landuré — Dernière modification 09/06/2014 06:23

GitLab est un clone libre de GitHub. Interface Web de gestion de dépôts Git. Ce guide facilite son installation depuis les sources sur Debian.

Ce guide est testé sur:

  • Debian 7.0 Wheezy

Ce guide est testé avec ces versions de GitLab:

  • 6.9.2

Prérequis

Ce guide nécessite :

Paramètres

Renseignez le nom de domaine où sera disponible l'application:

domain="gitlab.example.com"

Renseignez le nom d'hôte du serveur PostgreSQL:

pgsqlHost="localhost"

Si le serveur PostgreSQL n'est pas local, l'outil pgsql-tools essaiera de s'y connecter avec le client PostgreSQL, ou, en cas d'échec de connexion, via une connexion SSH.

Renseignez le nom d'hôte du serveur Redis:

redisHost="localhost"

Renseignez le nom du certificat SSL à utiliser pour chiffrer l'application avec HTTPS (créé via la procédure Créer un certificat SSL / TLS sur Debian) (optionnel, recommandé):

sslKeyName="${domain}"

Paramètres de l'application

Renseignez l'adresse email envoyant les messages générés par GitLab:

fromEmail="gitlab@domain.com"

Renseignez l'adresse email du contact technique:

supportEmail="support@domain.com"

Renseignez l'URL de Redmine, s'il est utilisé en tant qu'outil de gestion de projet:

redmineUrl="https://redmine.domain.com"

Paramètres de Git

Renseignez l'email du compte Git utilisé pour les modifications de fichier par l'interface Web:

gitUserEmail='gitlab@domain.com'

Renseignez l'email du compte Git utilisé pour les modifications de fichier par l'interface Web:

gitUsername='Gitlab'

Installation

Détectez le proxy de commande (command ou sudo):

cmdProxy='command'
command type -f 'sudo' &>'/dev/null' && cmdProxy='sudo'

Déterminez le chemin d'installation:

installPath="/opt/gitlab/${domain}"

Déterminez le chemin des données:

dataPath="/var/lib/gitlab/${domain}"

Déterminez le chemin du cache:

cachePath="/var/cache/gitlab/${domain}"

Déterminez le chemin des journaux:

logPath="/var/log/gitlab/${domain}"

Déterminez les chemins utilisés par l'application:

satellitePath="${installPath}/gitlab-satellites/"
backupsPath="${installPath}/backups"
repositoriesPath="${installPath}/repositories/"
hookPath="${installPath}/gitlab-shell/hooks/"
gitlabShellPath="${dataPath}/gitlab-shell"

Assurez-vous que les dossiers existent:

${cmdProxy} mkdir --parent "${installPath}"
${cmdProxy} mkdir --parent "${dataPath}/gitlab-satellites"
${cmdProxy} mkdir --parent "${dataPath}/repositories"
${cmdProxy} mkdir --parent "${gitlabShellPath}"
${cmdProxy} mkdir --parent "${dataPath}/backups"
${cmdProxy} mkdir --parent "$(dirname "${cachePath}")"
${cmdProxy} mkdir --parent "$(dirname "${logPath}")"

Déterminez le protocole utilisé par l'application:

proto='http'
if [ -n "${sslKeyName}" -a -e "/etc/ssl/private/${sslKeyName}.key" ]; then
  proto='https'
fi

Préparation de l'environnement

Installez les logiciels nécessaires:

${cmdProxy} apt-get install build-essential zlib1g-dev \
    libyaml-dev libssl-dev libgdbm-dev libreadline-dev libncurses5-dev libffi-dev \
    curl openssh-server checkinstall libxml2-dev libxslt-dev \
    libcurl4-openssl-dev libicu-dev logrotate git-core libpq-dev \
 python-docutils libpod-simple-perl libpod-simple-wiki-perl

Créez l'utilisateur git:

${cmdProxy} adduser --home "${dataPath}" --gecos 'GitLab' \
    --no-create-home --disabled-password \
    --system --group git

Ajustez les permissions:

${cmdProxy} chown -R git:git "${dataPath}"

Installez les gemmes Ruby nécessaires:

${cmdProxy} gem install redcarpet RedCloth org-ruby creole wikicloth asciidoc
${cmdProxy} gem install rdoc -v 3.6.1

Création de la base de données

Créez l'utilisateur privilégié :

pgsqlParams="$(command pgsql-tools --server="${pgsqlHost}" --user-prefix="gitlab" \
    --db-prefix="gitlab" --create="${domain}" --auto-hosts --createdb)"

Récupérez les paramètres de la nouvelle base de données:

pgsqlDb="$(echo "${pgsqlParams}" | command grep -e "^PGSQL_DB" \
    | command cut --delimiter="=" --fields="2-")"
pgsqlUser="$(echo "${pgsqlParams}" | command grep -e "^PGSQL_USER" \
    | command cut --delimiter="=" --fields="2-")"
pgsqlPassword="$(echo "${pgsqlParams}" | command grep -e "^PGSQL_PASSWORD" \
    | command cut --delimiter="=" --fields="2-")"
echo "${pgsqlParams}"

Créez un fichier temporaire contenant les paramètres de connexion à la base de données:

pgPassFile="$(command mktemp -t "tmp.XXXXXXXXXX")"
command chmod go-rw "${pgPassFile}"
echo "${pgsqlHost}:*:*:${pgsqlUser}:${pgsqlPassword}" > "${pgPassFile}"

Créez la structure de la base de données:

env PGPASSFILE="${pgPassFile}" psql --host="${pgsqlHost}" --dbname "${pgsqlDb}" \
    --username "${pgsqlUser}" --file="${installPath}/structure.sql"

Mise en place du logiciel

Détectez le numéro de la dernière version stable:

version="$(command wget --quiet 'https://gitlab.com/gitlab-org/gitlab-ce/tree/master' -O - \
    | command grep -- '-stable' \
    | command cut --delimiter='"' --fields=2 \
    | command tail -n 1)"

Téléchargez les sources du logiciel:

${cmdProxy} git clone 'https://gitlab.com/gitlab-org/gitlab-ce.git' -b "${version}" "${installPath}"

Ajustez l'emplacement des dossiers:

${cmdProxy} mv "${installPath}/log" "${logPath}"
${cmdProxy} ln -s "${logPath}" "${installPath}/log"
${cmdProxy} mv "${installPath}/tmp" "${cachePath}"
${cmdProxy} ln -s "${cachePath}" "${installPath}/tmp"
${cmdProxy} mv "${installPath}/public/uploads" "${dataPath}"
${cmdProxy} ln -s "${dataPath}/uploads" "${installPath}/public/uploads"
${cmdProxy} mkdir "${dataPath}/assets"
${cmdProxy} ln -s "${dataPath}/assets" "${installPath}/public/assets"
${cmdProxy} mv "${installPath}/vendor" "${dataPath}"
${cmdProxy} ln -s "${dataPath}/vendor" "${installPath}/vendor"

Ajustez les permissions:

${cmdProxy} chown git:git "${installPath}"
${cmdProxy} chown -R git:git "${dataPath}" "${logPath}" "${cachePath}"
${cmdProxy} chmod -R 770 "${dataPath}" "${logPath}" "${cachePath}"

Configuration de GitLab

Créez le fichier de configuration de la base de données:

echo "production:
  adapter: postgresql
  encoding: unicode
  database: ${pgsqlDb}
  pool: 10
  username: ${pgsqlUser}
  password: ${pgsqlPassword}
  host: ${pgsqlHost}
  port: 5432" > "${installPath}/config/database.yml"
if [[ "${pgsqlHost}" = 'localhost' ]]; then
  echo "  socket: /var/run/postgresql/.s.PGSQL.5432" >> "${installPath}/config/database.yml"
fi

Créez le fichier de configuration:

${cmdProxy} cp "${installPath}/config/gitlab.yml.example" "${installPath}/config/gitlab.yml"

Ajustez la configuration:

${cmdProxy} sed -i \
  -e "s/host: localhost/host: ${domain}/" \
  -e "s/ email_from: .*/ email_from: ${fromEmail}/" \
  -e "s/ support_email: .*/ support_email: ${supportEmail}/" \
  -e "/issues_tracker:/a\\
    redmine:\\
      title: 'Redmine'\\
      project_url: '${redmineUrl}/projects/:issues_tracker_id'\\
      issues_url: '${redmineUrl}/issues/:id'\\
      new_issue_url: '${redmineUrl}/projects/:issues_tracker_id/issues/new'" \
  "${installPath}/config/gitlab.yml"

Ajustez le protocole si nécessaire:

if [ -n "${sslKeyName}" -a -e "/etc/ssl/private/${sslKeyName}.key" ]; then
  ${cmdProxy} sed -i \
      -e 's/port: 80/port: 443/' \
      -e 's/https: false/https: true/' \
    "${installPath}/config/gitlab.yml"
fi

Configurez les chemins:

${cmdProxy} sed -i \
    -e "s|/home/git/gitlab-satellites/|${satellitePath}|" \
    -e "s|tmp/backups|${backupsPath}|" \
    -e "s|/home/git/repositories/|${repositoriesPath}|" \
    -e "s|/home/git/gitlab-shell/hooks/|${hookPath}|" \
    -e "s|/home/git/gitlab-shell/|${gitlabShellPath}|" \
    -e "s|/usr/bin/git|$(command -v 'git')|" \
  "${installPath}/config/gitlab.yml"

Créez le fichier de configuration de Rack Attack:

${cmdProxy} cp "${installPath}/config/initializers/rack_attack.rb.example" "${installPath}/config/initializers/rack_attack.rb"

Créez le fichier de configuration de Resque:

${cmdProxy} cp "${installPath}/config/resque.yml.example" "${installPath}/config/resque.yml"
${cmdProxy} sed -i -e "s/redis.example.com/${redisHost}/" "${installPath}/config/resque.yml"

Configurez l'envoi des emails:

command echo "if Rails.env.production?
  Gitlab::Application.config.action_mailer.delivery_method = :smtp

  ActionMailer::Base.smtp_settings = {
    address: \"localhost\",
    port: 25,
    enable_starttls_auto: false
  }
end" \
  | ${cmdProxy} tee "${installPath}/config/initializers/smtp_settings.rb"

Configuration du serveur HTTP Unicorn

GitLab est fournit avec le serveur HTTP Unicorn. Créez le fichier de configuration:

${cmdProxy} cp "${installPath}/config/unicorn.rb.example" "${installPath}/config/unicorn.rb"

Ajustez la configuration:

${cmdProxy} sed -i \
    -e "s|/home/git/gitlab/tmp|${cachePath}|" \
    -e "s|/home/git/gitlab/log|${logPath}|" \
    -e "s|/home/git/gitlab|${installPath}|" \
  "${installPath}/config/unicorn.rb"

Remarque: si votre serveur est destiné à supporter de fortes charges et qu'il dispose d'au moins 2Go de mémoire, augmentez le nombre de threads de Unicorn:

# ${cmdProxy} sed -i -e 's|^worker_processes.*$|worker_processes 3|' "${installPath}/config/unicorn.rb"

Configuration de Git

Renseignez l'utilisateur par défaut de Git:

sudo -u 'git' -H git config --global user.name "${gitUsername}"
sudo -u 'git' -H git config --global user.email "${gitUserEmail}"
sudo -u 'git' -H git config --global core.autocrlf input

Installation des dépendances

Installez les dépendances de GitLab:

command pushd "${installPath}"
sudo -u 'git' -H bundle install --deployment --without development test mysql aws
command popd

Installation de GitLab Shell

Détectez la dernière version de l'application:

version="$(command wget --quiet --no-check-certificate "https://github.com/gitlabhq/gitlab-shell" -O - \
  | command grep "tree/v" \
  | command head -n 1 \
  | command sed -e 's|.*/tree/\(v.*\)"|\1|')"

Installez l'application:

command pushd "${installPath}" 
sudo -u git -H bundle exec rake gitlab:shell:install[${version}] REDIS_URL="redis://${redisHost}:6379" RAILS_ENV=production
command popd

Initialisation de la base de données

Initialisez le contenu de la base de données:

command pushd "${installPath}" 
sudo -u git -H bundle exec rake gitlab:setup RAILS_ENV=production <<< 'yes'
command popd

Important: Notez les informations d'identification de l'administrateur.

Mise en place de la rotation des journaux

Configurez la rotation des journaux:

${cmdProxy} cp "${installPath}/lib/support/logrotate/gitlab" '/etc/logrotate.d/gitlab'
${cmdProxy} sed -i \
    -e "s|/home/git/gitlab/log|${logPath}|g" \
    -e "s|/home/git/gitlab-shell|${gitlabShellPath}|g" \
  '/etc/logrotate.d/gitlab'

Vérification de la configuration

Vérifiez la configuration:

command pushd "${installPath}" 
sudo -u git -H bundle exec rake gitlab:env:info RAILS_ENV=production
command popd

Générez les assets:

command pushd "${installPath}" 
sudo -u git -H bundle exec rake assets:precompile RAILS_ENV=production
command popd

Mise en place du script init.d

Mettez en place le script init.d:

${cmdProxy} cp "${installPath}/lib/support/init.d/gitlab" '/etc/init.d/gitlab'
${cmdProxy} cp "${installPath}/lib/support/init.d/gitlab.default.example" '/etc/default/gitlab'

Mettez à jour la configuration:

${cmdProxy} sed -i \
    -e "s|^app_root=.*|app_root='${installPath}'|" \
    -e "s|^pid_path=.*|pid_path='${cachePath}/pids'|" \
    -e "s|^socket_path=.*|socket_path='${cachePath}/sockets'|" \
  '/etc/default/gitlab'

Ajoutez GitLab au démarrage du système:

${cmdProxy} update-rc.d gitlab defaults 21

Démarrez GitLab:

${cmdProxy} service gitlab start

Configuration du serveur HTTP

Créez la configuration Apache 2 personnalisée:

customVhost=" ProxyPreserveHost On
  <Location />
    Order deny,allow
    Allow from all
    ProxyPassReverse http://127.0.0.1:8080
    ProxyPassReverse http://${domain}/
  </Location>

  #apache equivalent of nginx try files
  # http://serverfault.com/questions/290784/what-is-apaches-equivalent-of-nginxs-try-files
  # http://stackoverflow.com/questions/10954516/apache2-proxypass-for-rails-app-gitlab
  RewriteEngine on
  RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} "\!"-f
  RewriteRule .* http://127.0.0.1:8080%{REQUEST_URI} [P,QSA]
  RequestHeader set X_FORWARDED_PROTO '${proto}'

  # needed for downloading attachments
  DocumentRoot ${installPath}/public
  #Set up apache error documents, if back end goes down (i.e. 503 error) then a maintenance/deploy page is thrown up.
  ErrorDocument 404 /404.html
  ErrorDocument 422 /422.html
  ErrorDocument 500 /500.html
  ErrorDocument 503 /deploy.html"

Activez les modules Apache nécessaires:

${cmdProxy} a2enmod rewrite proxy proxy_http headers

Créez la configuration Apache 2 de l'outil:

if [ -n "${sslKeyName}" -a -e "/etc/ssl/private/${sslKeyName}.key" ]; then
  ${cmdProxy} a2tools --template='custom' --ssl="${sslKeyName}" \
      "${domain}" "${customVhost}"
  ${cmdProxy} a2tools --template='redirect' "${domain}" "https://${domain}/"
else
  ${cmdProxy} a2tools --template='custom' "${domain}" "${customVhost}"
fi

Accédez à l'application via l'URL fournie:

echo "http://${domain}/"

Les identifiants de l'utilisateur d'administration ont été fournis lors de l'initialisation de la base de données.

Sauvegardes

Sauvegardez l'installation avec Backup Manager (voir Installer et configurer Backup Manager sur Debian):

${cmdProxy} backup-manager-tools add "${installPath}"
${cmdProxy} backup-manager-tools add "${dataPath}"

N'oubliez pas de sauvegarder la base de données (voir Installer PostgreSQL sur Debian).

Remerciements