Gitlab bietet, sofern aktiviert, auch die Funktion einer docker Registry für ein Repo an.
Damit ist es möglich neben dem Quellcode auch gleich die entsprechenden docker Images bereitzustellen.

Zu Beginn sollte sollte eine entsprechende Gitlab-Instanz vorhanden sein.
Falls nicht, findet sich hier die entsprechende Anleitung: Installation von Gitlab-CE

Des weiteren muss für die docker Registry eine passende Domain vorhanden sein, welche auf die entsprechende Gitlab-Instanz auflöst.

Erstellen der OpenSSL Zertifikate

Mit dem folgenden Befehl erstellen wir in /etc/gitlab/ssl ein entsprechendes Zertifikat für die (Sub)domain unter der die docker Registry erreichbar ist.
openssl req -newkey rsa:4096 -nodes -sha256 -keyout /etc/gitlab/ssl/registry.domain.com.key -x509 -out /etc/gitlab/ssl/registry.domain.com.crt
Diesen könnte man mit dem der zusätzlichen Option -days entsprechend zeitlich begrenzen.

Bei der Erstellung wird dann noch nach üblichen Daten gefragt. Ich empfehle wenigstens die folgenden Angaben zu machen:

Common Name (e.g. server FQDN or YOUR name) []:registry.domain.com                                                     
Email Address []:info@registry.domain.com                         

Und nun noch ein chmod 600 /etc/gitlab/ssl/registry.domain.com.* um die Berechtigungen anzupassen.

Konfigurieren von Gitlab

In der /etc/gitlab/gitlab.rb legen wir folgende Einstellungen fest:

• registry_external_url 'https://registry.domain.com' —> gibt die Domain an unter welcher die Registry zu erreichen ist
• gitlab_rails['registry_path'] = "/var/opt/gitlab/gitlab-rails/shared/registry" —> der Ort an dem die Images gespeichert werden
• gitlab_rails['gitlab_default_projects_features_container_registry'] = true —> damit ist die Registry-Funktion bei jedem neuen Projekt bereits aktiviert (OPTIONAL)
• registry['enable'] = true —> aktiviert die docker Registry
• registry_nginx['enable'] = true
• registry_nginx['ssl_certificate'] = "/etc/gitlab/ssl/registry.domain.com.crt" —> Pfad zum vorher erstellten crt
• registry_nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/registry.domain.com.key" —> Pfad zum vorher erstellten key

Mit dem Befehl gitlab-ctl reconfigure aktivieren wir das neue Feature.

Sofern keine Fehler auftreten sollte die Meldung gitlab Reconfigured! erscheinen.

Anmerkung: Standardmäßig wird Port 5000 für das ansprechen der Registry verwendet, daher muss man daran denken diesen in der Firewall entsprechend freizuschalten.

Registry für ein Projekt verwenden

Zum testen legen wir im Gitlab ein neues Repo an.

Meines nenne ich docker Registry.
Wenn man sich nun in Gitlab im Repo befindet sollte man im Menü auf der linken Seite einen entsprechenden Menüpunkt namens Registry finden:

Beim klick auf diesen Menüpunkt finden wir Informationen wie wir docker Container in diese Registry pushen können:

Hinterlegen des Zertifikats im docker Client

Damit der docker Client sich mit der Registry verbinden kann erstellen wir als erstes ein entsprechendes Verzeichnis:
mkdir -p /etc/docker/certs.d/registry.domain.com
und dort hinein kopieren wir von der Gitlab-Instanz das /etc/gitlab/ssl/registry.domain.com.crt. Dieses muss beim docker Client aber als ca.crt abgelegt werden!

Anschließend erfolgt ein reload des docker Dienstes per systemctl reload docker.service.

Einloggen

Nachdem das Zertifikat hinterlegt ist, loggen wir uns mit den regulären Gitlab-Zugangsdaten in die Registry ein:

$ docker login registry.domain.com                                                                                                                                                                                         
Username: rasputin                                                                                                                                                                                                                            
Password:                                                                                                                                                                                                                                     
WARNING! Your password will be stored unencrypted in /home/rasputin/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

ein Image in die Registry pushen

Nun bauen wir das Image, welches wir anschließend in die neue Registry pushen wollen:

$ docker build -t registry.domain.com/rasputin/docker-registry .                                                                                                                                                            
Sending build context to Docker daemon  2.048kB                                                                                                                                                                                               
Step 1/7 : FROM golang as build_image                                                                                                                                                                                                         
latest: Pulling from library/golang
...
Successfully built 8cf3b70097d9                                                                                                                                                                                                               
Successfully tagged registry.domain.com/rasputin/docker-registry:latest

Nun folgt der Push:

$ docker push registry.domain.com/rasputin/docker-registry                                                                                                                                                                  
The push refers to repository [registry.domain.com/rasputin/docker-registry]                                                                                                                                                
335720f64db0: Pushed                                                                                                                                                                                                                          
256a7af3acb1: Pushed                                                                                                                                                                                                                          
latest: digest: sha256:df191c3132e744fdc29d9e8cd08db515bf8fc71a6b6369e83da5c98ba2a5b657 size: 739

Nun sollte das erste Image in Gitlab sichtbar sein:

Nun lässt dich das Image natürlich auch herunterladen:

$ docker pull registry.domain.com/rasputin/docker-registry
Using default tag: latest
latest: Pulling from rasputin/docker-registry
921b31ab772b: Already exists 
6f3bf99e8c16: Pull complete 
Digest: sha256:df191c3132e744fdc29d9e8cd08db515bf8fc71a6b6369e83da5c98ba2a5b657
Status: Downloaded newer image for registry.domain.com/rasputin/docker-registry:latest
registry.domain.com/rasputin/docker-registry:latest

Wie bereits erwähnt kann man parallel zur Registry-Funktion das entsprechende Repo regulär mit dem passenden Quellcode befüllen: