mirroir readonly du Gitit wiki.evolix.org (attention, ne rien commiter/merger sur ce dépôt) https://wiki.evolix.org
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
1 year ago
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631
  1. ---
  2. categories: web git
  3. title: Howto GitLab
  4. ...
  5. * Documentation : <https://gitlab.com/gitlab-org/gitlab-ce/blob/master/doc/install/installation.md>
  6. [GitLab](https://about.gitlab.com/) est un logiciel libre de gestion de développement de logiciels (appelé souvent une *forge*) permettant de créer des projets avec un dépôt Git pour le code source, un outil de tickets, un wiki, une collaboration autour de Git (merge/pull requests, etc.). GitLab ressemble sous certains aspects au logiciel propriétaire *Github*.
  7. # Installation
  8. Nous installons la version **11** sous **Debian 9** (Stretch) avec une approche multi-instances.
  9. GitLab s'appuie sur Git, Ruby, Go, Nginx, NodeJS, PostgreSQL et Redis.
  10. > **Note** : dans les exemples ci-dessous, on va créer une instance nommée *foo*
  11. ## Dépendances
  12. GitLab nécessite des versions très récentes de Git, Ruby, Go, NginX et NodeJS.
  13. On utilise des versions de Stretch Backports pour Git, Go et NginX via un « pinning » APT :
  14. ~~~
  15. Package: *
  16. Pin: release n=stretch-backports
  17. Pin-Priority: 50
  18. Package: git git-man golang golang-doc golang-src golang-go nginx nginx-* libnginx-*
  19. Pin: release n=stretch-backports
  20. Pin-Priority: 999
  21. ~~~
  22. Pour NodeJS, il faut l'installer [ainsi](https://wiki.evolix.org/HowtoNodeJS).
  23. Il faut aussi installer [Yarn](https://wiki.evolix.org/HowtoYarn).
  24. Ruby sera installé manuellement en version 2.5.3.
  25. On peut ainsi installer toutes les dépendances pour Gitlab :
  26. ~~~
  27. # apt install autotools-dev bison build-essential checkinstall chrpath cmake coreutils curl file git golang libbison-dev libcurl4-openssl-dev libffi-dev libgdbm-dev libgmp-dev libicu-dev libjemalloc-dev libncurses5-dev libncursesw5-dev libre2-dev libreadline6-dev libreadline-dev libssl1.0-dev libxml2-dev libxslt-dev libyaml-dev logrotate netbase nodejs openssh-server openssl pkg-config procps python-docutils systemtap-sdt-dev tcl8.6-dev tk8.6-dev yarn zlib1g-dev
  28. ~~~
  29. ## Compte UNIX
  30. Créer un compte UNIX *foo* :
  31. ~~~
  32. # adduser --disabled-login --gecos 'GitLab instance foo' foo
  33. ~~~
  34. > **Note** : Assurez-vous d'avoir `DIR_MODE=0750` dans `/etc/adduser.conf` pour créer le home en 750.
  35. ## PostgreSQL
  36. GitLab recommande [PostgreSQL](HowtoPostgreSQL). On utilise donc la version 9.6 de Debian Stretch :
  37. ~~~
  38. # apt install postgresql postgresql-client libpq-dev postgresql-contrib
  39. ~~~
  40. Création de l'utilisateur PostgreSQL :
  41. ~~~
  42. # sudo -u postgres createuser foo -d -P -R
  43. ~~~
  44. > **Note** : On donne les droits CREATEDB car GitLab doit faire un DROP DATABASE puis CREATE DATABASE lors de l'installation…
  45. > **Note** : Pensez à conserver le mot de passe pour le mettre par la suite pour [GitLab CE](#gitlab-ce).
  46. Création de l'extension `pg_trgm` :
  47. ~~~
  48. # sudo -u postgres psql -d template1 -c "CREATE EXTENSION IF NOT EXISTS pg_trgm;"
  49. ~~~
  50. > **Note** : C'est à faire seulement la première fois.
  51. Création de la base pour GitLab :
  52. ~~~
  53. # sudo -u postgres createdb -O foo -E UNICODE foo
  54. ~~~
  55. Tester la connexion et si l'extension `pg_trgm` est bien activée :
  56. ~~~
  57. # sudo -u foo -H psql --password -d foo
  58. psql> SELECT true AS enabled FROM pg_available_extensions
  59. WHERE name = 'pg_trgm' AND installed_version IS NOT NULL;
  60. enabled
  61. ---------
  62. t
  63. (1 row)
  64. ~~~
  65. ## Redis
  66. On utilise une instance Redis dédiée à chaque instance GitLab :
  67. ~~~
  68. # apt install redis-server
  69. # systemctl stop redis-server
  70. # systemctl disable redis-server
  71. ~~~
  72. Créer et activer le template d'unité systemd `/etc/systemd/system/redis@.service` :
  73. ~~~
  74. [Unit]
  75. Description=Advanced key-value store instance %i
  76. After=network.target
  77. [Service]
  78. Type=forking
  79. ExecStart=/usr/bin/redis-server /etc/redis/%i.conf
  80. ExecStartPost=/bin/chgrp %i /var/run/redis/%i.sock
  81. ExecStop=/usr/bin/redis-cli shutdown
  82. Restart=always
  83. User=redis
  84. Group=%i
  85. [Install]
  86. WantedBy=multi-user.target
  87. ~~~
  88. Puis :
  89. ~~~
  90. # systemctl daemon-reload
  91. ~~~
  92. Configuration spéciale pour l'instance :
  93. ~~~
  94. # cat /etc/redis/foo.conf
  95. daemonize yes
  96. pidfile /var/run/redis/foo.pid
  97. port 0
  98. unixsocket /var/run/redis/foo.sock
  99. unixsocketperm 770
  100. timeout 0
  101. loglevel notice
  102. logfile /var/log/redis/foo.log
  103. databases 16
  104. save 900 1
  105. save 300 10
  106. save 60 10000
  107. stop-writes-on-bgsave-error yes
  108. rdbcompression yes
  109. rdbchecksum yes
  110. dbfilename foo.rdb
  111. dir /var/lib/redis
  112. # chmod 644 /etc/redis/foo.conf
  113. # systemctl enable redis@foo
  114. # systemctl start redis@foo
  115. ~~~
  116. ## GitLab CE
  117. ~~~
  118. # sudo -iu foo
  119. $ umask 002
  120. $ git clone https://gitlab.com/gitlab-org/gitlab-ce.git -b 11-6-stable gitlab
  121. $ cd gitlab
  122. $ cp config/gitlab.yml.example config/gitlab.yml
  123. $ sed -i 's@/home/git@/home/foo@g' config/gitlab.yml
  124. ~~~
  125. Éditer `config/gitlab.yml` :
  126. ~~~
  127. host: foo.gitlab.example.com
  128. port: 443
  129. https: true
  130. user: foo
  131. email_from: gitlab@example.com
  132. email_display_name: GitLab foo
  133. email_reply_to: gitlab@example.com
  134. ~~~
  135. Mettre une clé secrète pour le chiffrement en base.
  136. ~~~
  137. $ cp config/secrets.yml.example config/secrets.yml
  138. $ sed -i "s@# db_key_base:@db_key_base: YOURSECRETKEY@" config/secrets.yml
  139. $ chmod 600 config/secrets.yml
  140. ~~~
  141. > **Note** : Il est conseillé de générer `YOURSECRETKEY` ainsi : `apg -m30 -n1`.
  142. > **Note** : Il est conseillé de sauvegarder le fichier secrets.yml. Voir la section [sauvegarde](#sauvegarde).
  143. Mettre le mot de passe PostgreSQL :
  144. ~~~
  145. $ cp config/database.yml.postgresql config/database.yml
  146. $ sed -i -e 's/database: gitlabhq_production/database: foo/' \
  147. -e 's/# username: git/username: foo/' \
  148. -e 's/# password:/password: PASSWORD/' config/database.yml
  149. $ chmod o-rwx config/database.yml
  150. ~~~
  151. > **Note** : Conservez l'espace devant le `sed` pour ne pas enregistrer le mot de passe dans l'historique BASH.
  152. Ajuster les droits de certains répertoires :
  153. ~~~
  154. $ chmod 750 ~
  155. $ chmod -R u+rwX,go-w log/
  156. $ chmod -R u+rwX {tmp/,tmp/pids/,builds,shared/artifacts/,shared/pages}
  157. $ chmod -R u+rwX,g+rwX tmp/sockets/
  158. $ install -d -m 700 public/uploads/
  159. ~~~
  160. ## Unicorn
  161. Configuration de base d'Unicorn :
  162. ~~~
  163. $ cp config/unicorn.rb.example config/unicorn.rb
  164. $ sed -i \
  165. -e 's@/home/git@/home/foo@g' \
  166. -e 's/listen "127.0.0.1:8080", :tcp_nopush => true/#listen "127.0.0.1:8080", :tcp_nopush => true/' \
  167. config/unicorn.rb
  168. ~~~
  169. ## Rack attack
  170. Initialisation de la configuration de Rack::Attack (qui permet du filtrage / rate-limiting) :
  171. ~~~
  172. $ cp config/initializers/rack_attack.rb.example config/initializers/rack_attack.rb
  173. ~~~
  174. ## Git
  175. Configuration :
  176. ~~~
  177. $ git config --global core.autocrlf input
  178. $ git config --global gc.auto 0
  179. $ git config --global repack.writeBitmaps true
  180. $ git config --global receive.advertisePushOptions true
  181. ~~~
  182. ## Resque
  183. Configuration :
  184. ~~~
  185. $ cp config/resque.yml.example config/resque.yml
  186. $ sed -i 's/redis.sock/foo.sock/' config/resque.yml
  187. ~~~
  188. ## Ruby
  189. > **Important**: Votre partition `/home` ne doit pas être montée avec l'option `noexec`.
  190. Installation manuelle à ne faire qu'une fois ou pour mettre à jour la version de Ruby :
  191. ~~~
  192. $ cd ~
  193. $ mkdir -p tmp/ruby
  194. $ cd tmp/ruby
  195. $ curl --remote-name --progress https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.3.tar.gz
  196. $ echo 'f919a9fbcdb7abecd887157b49833663c5c15fda ruby-2.5.3.tar.gz' | shasum -c - && tar xzf ruby-2.5.3.tar.gz
  197. $ cd ruby-2.5.3
  198. $ ./configure --disable-install-rdoc --with-jemalloc
  199. $ make -j$(nproc)
  200. # make install
  201. # gem install bundler --no-document --version '< 2'
  202. # chmod -R u=rwX,g=rX,o=rX /usr/local/
  203. ~~~
  204. ## Gems
  205. On installe les Gems requise :
  206. ~~~
  207. # sudo -iu foo
  208. $ cd gitlab
  209. $ bundle install -j$(nproc) --deployment --without development test mysql aws kerberos
  210. ~~~
  211. ## GitLab Shell
  212. Installation :
  213. ~~~
  214. $ bundle exec rake gitlab:shell:install REDIS_URL=unix:/var/run/redis/foo.sock RAILS_ENV=production SKIP_STORAGE_VALIDATION=true
  215. $ chmod -R ug+rwX,o-rwx ~/repositories/
  216. $ chmod -R ug-s ~/repositories/
  217. $ chmod g+s ~/repositories/
  218. ~~~
  219. ## gitlab-workhorse
  220. Installation :
  221. ~~~
  222. $ bundle exec rake "gitlab:workhorse:install[/home/foo/gitlab-workhorse]" RAILS_ENV=production
  223. ~~~
  224. ## gitaly
  225. Installation :
  226. ~~~
  227. $ bundle exec rake "gitlab:gitaly:install[/home/foo/gitaly,/home/foo/repositories]" RAILS_ENV=production
  228. $ chmod 0700 /home/foo/gitlab/tmp/sockets/private
  229. $ app_root=/home/foo/gitlab
  230. $ gitaly_dir=/home/foo/gitaly
  231. $ $app_root/bin/daemon_with_pidfile $app_root/tmp/pids//gitaly.pid $gitaly_dir/gitaly $gitaly_dir/config.toml >> $app_root/log/gitaly.log 2>&1 &
  232. ~~~
  233. ## Base de données
  234. On crée la base de données avec l'identifiant (une adresse email) et un mot de passe pour l'utilisateur *root* sur l'interface web de GitLab :
  235. ~~~
  236. $ cd ~/gitlab
  237. $ bundle exec rake gitlab:setup RAILS_ENV=production GITLAB_ROOT_PASSWORD=yourpassword GITLAB_ROOT_EMAIL=admingitlab@example.com
  238. ~~~
  239. > **Note** : Conservez l'espace devant le `bundle` pour ne pas enregistrer le mot de passe dans l'historique BASH.
  240. ## Script d'init
  241. Attention, GitLab ne supporte pas officiellement systemd !
  242. On doit donc encore passer pas un script d'init classique :
  243. ~~~
  244. $ sed -i -e 's/app_user="git"/app_user="foo"/' \
  245. -e 's/# Provides: .*gitlab/# Provides: gitlab-foo/' \
  246. lib/support/init.d/gitlab
  247. $ sed -i 's@script_path = "/etc/init.d/gitlab"@script_path = "/etc/init.d/gitlab-foo"@g' lib/tasks/gitlab/check.rake
  248. $ git commit -a -m 'change default user'
  249. # install -m 755 /home/foo/gitlab/lib/support/init.d/gitlab /etc/init.d/gitlab-foo
  250. # systemctl enable gitlab-foo
  251. ~~~
  252. ## Logrotate
  253. ~~~
  254. # install -m 644 /home/foo/gitlab/lib/support/logrotate/gitlab /etc/logrotate.d/gitlab-foo
  255. # sed -i 's@/home/git@/home/foo@g' /etc/logrotate.d/gitlab-foo
  256. ~~~
  257. ## Nginx
  258. On utilise Nginx, c'est le seul serveur web supporté officiellement par GitLab :
  259. ~~~
  260. # apt install nginx
  261. # adduser www-data foo
  262. # chmod -R g+rwX /home/foo/gitlab/tmp/{pids,sockets}
  263. # install -m 644 /home/foo/gitlab/lib/support/nginx/gitlab-ssl /etc/nginx/sites-available/foo
  264. # sed -i -e 's@/home/git@/home/foo@g' \
  265. -e 's/YOUR_SERVER_FQDN/foo.gitlab.example.com/g' \
  266. -e 's@/var/log/nginx/gitlab@/var/log/nginx/foo@g' \
  267. -e 's/upstream gitlab-workhorse/upstream gitlab-foo-workhorse/' \
  268. -e 's@http://gitlab-workhorse@http://gitlab-foo-workhorse@' \
  269. /etc/nginx/sites-available/foo
  270. # ln -s /etc/nginx/sites-available/foo /etc/nginx/sites-enabled/
  271. # systemctl restart nginx
  272. ~~~
  273. > **Note** : La partie SSL/TLS n'est pas évoquée. À vous de faire le nécessaire avec un certificat Let's Encrypt par exemple. N'oubliez donc pas de modifier les directives `ssl_` dans le vhost.
  274. > **Note** : `apt install nginx` est à faire seulement la première fois.
  275. ## Finalisation de l'installation
  276. Vérification de l'état de l'installation :
  277. ~~~
  278. # sudo -iu foo
  279. $ cd gitlab
  280. $ bundle exec rake gitlab:env:info RAILS_ENV=production
  281. ~~~
  282. Compilation des traductions :
  283. ~~~
  284. $ bundle exec rake gettext:compile RAILS_ENV=production
  285. ~~~
  286. Compilation des assets :
  287. ~~~
  288. $ yarn install --production --pure-lockfile
  289. $ bundle exec rake gitlab:assets:compile RAILS_ENV=production NODE_ENV=production
  290. ~~~
  291. Démarrage de l'instance :
  292. ~~~
  293. # /etc/init.d/gitlab-foo start
  294. ~~~
  295. Vérifier le statut :
  296. ~~~
  297. # sudo -iu foo
  298. $ cd gitlab
  299. $ bundle exec rake gitlab:check RAILS_ENV=production
  300. ~~~
  301. Si tout est au vert, c'est bon ! On pourra aller sur l'instance via http://foo.gitlab.example.com
  302. # Sauvegarde
  303. On peut réaliser des sauvegardes grâce à la commande `bundle exec rake gitlab:backup:create RAILS_ENV=production`
  304. On peut ainsi mettre un cron pour l'utilisateur foo :
  305. ~~~
  306. # Create a full backup of the GitLab repositories and SQL database every day at 4am
  307. 0 4 * * * cd ~/gitlab && bundle exec rake gitlab:backup:create RAILS_ENV=production CRON=1
  308. ~~~
  309. Dans `~/gitlab/config/gitlab.yml` on pourra indiquer un temps de rétention. Par exemple pour garder 5j de backups `keep_time: 432000`
  310. > **Note** : Par défaut, les sauvegardes sont stockées dans ~/gitlab/tmp/backups. Il est évidemment conseillé de les sauvegarder ailleurs et sur une machine distante.
  311. Attention, le fichier `secrets.yml` contient les clés de chiffrements pour les sessions et les variables. Il n'est pas inclus dans les sauvegardes GitLab. Vous devez le copier au moins une fois dans un endroit sécurisé.
  312. # Mises à jour
  313. Le principe des mises à jour est basé sur un `git pull` et un `git checkout`.
  314. Ensemble de [scripts](https://forge.evolix.org/projects/evogitlab/repository) que l'on utilise. La procédure manuelle ci-après n'est peut-être pas à jour.
  315. ## Mise à jour mineure 11.a.b vers 11.c.d.
  316. Procédure générique. Il est possible de « sauter » plusieurs versions. Par exemple, de 11.0.7 à 11.1.4, etc.
  317. ### Sauvegarde
  318. ~~~
  319. # sudo -iu foo
  320. $ cd gitlab
  321. $ bundle exec rake gitlab:backup:create RAILS_ENV=production
  322. ~~~
  323. ### Mise à jour de GitLab
  324. ~~~
  325. $ umask 002
  326. $ git fetch --all -p
  327. $ git fetch -t
  328. $ git checkout -- Gemfile.lock db/schema.rb yarn.lock locale
  329. $ git checkout -B v11.x.y tags/v11.x.y
  330. $ sed -i -e s'/app_user="git"/app_user="foo"/' \
  331. -e 's/# Provides: .*gitlab$/# Provides: gitlab-foo/' \
  332. lib/support/init.d/gitlab
  333. $ sed -i 's#script_path = "/etc/init.d/gitlab"#script_path = "/etc/init.d/gitlab-foo"#g' lib/tasks/gitlab/check.rake
  334. $ git commit -a -m 'change default user'
  335. ~~~
  336. ### Mise à jour de gitlab-shell
  337. ~~~
  338. $ cd ~/gitlab-shell
  339. $ git fetch --all
  340. $ git checkout -B v$(cat ~/gitlab/GITLAB_SHELL_VERSION) tags/v$(cat ~/gitlab/GITLAB_SHELL_VERSION
  341. $ bin/compile
  342. ~~~
  343. ### Mise à jour de gitlab-workhorse
  344. ~~~
  345. $ cd ~/gitlab-workhorse
  346. $ git fetch --all
  347. $ git checkout -B v$(cat ~/gitlab/GITLAB_WORKHORSE_VERSION) tags/v$(cat ~/gitlab/GITLAB_WORKHORSE_VERSION)
  348. $ make
  349. ~~~
  350. ### Mise à jour de Gitaly
  351. ~~~
  352. $ cd ~/gitaly
  353. $ pkill -u gitaly
  354. $ git fetch --all --tags
  355. $ git checkout v$(<~/gitlab/GITALY_SERVER_VERSION)
  356. $ cp config.toml{.example,}
  357. $ sed -i "s#/home/git/#/home/${gitlabUser}/#g" config.toml
  358. $ make
  359. ~~~
  360. ### Mise à jour base de données, Gems et assets
  361. ~~~
  362. $ cd ~/gitlab
  363. $ bundle install --without development test mysql aws kerberos --deployment
  364. $ bundle clean
  365. $ bundle exec rake db:migrate RAILS_ENV=production
  366. $ git checkout -- package.json
  367. $ yarn install
  368. $ bundle exec rake yarn:install gitlab:assets:clean gitlab:assets:compile RAILS_ENV=production NODE_ENV=production
  369. $ bundle exec rake gettext:compile RAILS_ENV=production
  370. $ bundle exec rake cache:clear RAILS_ENV=production
  371. $ git commit -a -m 'upgraded to 11.x.y'
  372. ~~~
  373. ### Redémarrer GitLab
  374. ~~~
  375. # /etc/init.d/gitlab-foo restart
  376. ~~~
  377. ### Vérifier le statut
  378. ~~~
  379. # sudo -iu foo
  380. $ cd gitlab
  381. $ bundle exec rake gitlab:env:info RAILS_ENV=production
  382. $ bundle exec rake gitlab:check RAILS_ENV=production
  383. ~~~
  384. Si tout est au vert, la migration s'est bien passée !
  385. ## Mise à jour majeure
  386. C'est sensiblement la même chose mais il faudra merger des fichier de configurations pour appliquer des nouveaux paramètres.
  387. # Docker registry
  388. Cette documentation consiste à installer un registry Docker sur la même machine que GitLab.
  389. Il faut Docker installé sur la machine. Voir [/HowtoDocker]()
  390. ## Génération d'un ceriticat pour utiliser authentifier les jetons
  391. ~~~
  392. # sudo -iu git
  393. $ cd /home/git/gitlab/config
  394. $ openssl req -newkey rsa:2048 -sha256 -nodes -keyout registry.key -out registry.csr
  395. $ openssl x509 -req -sha256 -days 1000 -in registry.csr -signkey registry.key -out registry.crt
  396. $ cat registry.key registry.crt > registry.pem
  397. ~~~
  398. ## Installation et configuration du registry
  399. ~~~
  400. # cat < EOT > /etc/docker/registry/config.yml
  401. version: 0.1
  402. log:
  403. fields:
  404. service: registry
  405. storage:
  406. cache:
  407. blobdescriptor: inmemory
  408. filesystem:
  409. rootdirectory: /var/lib/registry
  410. http:
  411. addr: :5000
  412. headers:
  413. X-Content-Type-Options: [nosniff]
  414. health:
  415. storagedriver:
  416. enabled: true
  417. interval: 10s
  418. threshold: 3
  419. auth:
  420. token:
  421. realm: https://gitlab.example.com/jwt/auth
  422. service: container_registry
  423. issuer: gitlab-issuer
  424. rootcertbundle: /root/certs/certbundle
  425. EOT
  426. # docker run -d -p 5000:5000 --restart=always --name registry \
  427. -v /etc/docker/registry/config.yml:/etc/docker/registry/config.yml \
  428. -v /home/git/gitlab/shared/registry:/var/lib/registry \
  429. -v /home/git/gitlab/config/registry.pem:/root/certs/certbundle \
  430. registry:2
  431. ~~~
  432. ## Ajout d'un vhost nginx
  433. ~~~
  434. # install -m 644 /home/git/gitlab/lib/support/nginx/registry-ssl /etc/nginx/sites-available/
  435. ~~~
  436. Il suffit d'éditer seulement le server_name et les directives SSL avec un certificat valide.
  437. ## Config GitLab
  438. gitlab.yml
  439. ~~~
  440. registry:
  441. enabled: true
  442. host: registry.gitlab.example.com
  443. port: 443
  444. api_url: http://localhost:5000/
  445. key: config/registry.key
  446. path: shared/registry
  447. issuer: gitlab-issuer
  448. ~~~
  449. # Divers / FAQ
  450. ## Restaurer un backup vers un autre nom d'instance
  451. Si vous avez un backup de foo, que vous voulez restaurer dans bar, il faudra faire une restauration classique puis via psql :
  452. ~~~
  453. # sudo -iu postgres
  454. $ pg_dump foo > foo.sql
  455. $ psql bar < foo.sql
  456. ~~~
  457. ~~~
  458. # sudo -iu postgres psql bar
  459. REASSIGN OWNED BY "foo" TO "bar";
  460. ~~~
  461. ## Downgrader le schéma SQL
  462. Par exemple si on downgrade une version. Il faudra récupérer la bonne version dans db/migrate. Exemple :
  463. ```
  464. $ bundle exec rake db:migrate:redo RAILS_ENV=production VERSION=20161223034646
  465. ```