Docker Gitlab+Jenkins+Harbor erstellt einen persistenten Plattformbetrieb

CI/CD-Übersicht

CI-Workflow-Design

Das Git-Codeversionsverwaltungssystem kann nur über die Befehlszeile verwaltet werden

Gitlab hat eine grafische Verwaltungsseite auf Basis von Git entwickelt. Unternehmen nutzen Gitlab zur Verwaltung privater Code-Repositories

Öffentliches Code-Verwaltungs-Repository auf Github

Gitlab erstellen

Um Gitlab zu erstellen, erstellen Sie zuerst ein Arbeitsverzeichnis, da einige Daten persistent gespeichert werden müssen

[root@www ~]# mkdir -p /gitlab
[root@www ~]# cd /gitlab/
 
docker run -d \
 --name gitlab \
 -p 8443:443 \
 -p 9999:80 \
 -p 9998:22 \
 -v /gitlab/config:/etc/gitlab \
 -v /gitlab/logs:/var/log/gitlab \
 -v /gitlab/data:/var/opt/gitlab \
 -v /etc/lokaleZeit:/etc/lokaleZeit \
 --restart=immer \
 lizhenliang/gitlab-ce-zh:latest

9999 ist der Web-Port 8443 Web-HTTPS-Port 9998 SSH-Port

Behalten Sie die Containerdaten auf dem lokalen Host bei. Dieses Image wurde nach der frühen chinesischen Übersetzung erstellt. Das offizielle Standardimage ist auf Englisch. Dieses hier ist auf Englisch. Dieses Image ist relativ groß, etwa 1 GB, einschließlich Datenbanken und Nachrichtenwarteschlangen, und es gibt viele gekapselte Inhalte.

[root@www gitlab]# Docker-Protokolle 3396d5ccc518 
  - Führen Sie /opt/gitlab/bin/gitlab-ctl aus, um PostgreSQL zu starten.
+psql_host='/var/opt/gitlab/postgresql'

Durch das Protokoll können Sie sehen, welche Komponenten wie postgresql

Der erste Besuch kann etwas langsam sein, da es viele Komponenten gibt und Sie möglicherweise 3-5 Minuten warten müssen

Das Erscheinen dieser Seite zeigt an, dass der Gitlab-Dienst gestartet wurde, andere Komponenten jedoch möglicherweise nicht erfolgreich gestartet wurden. Am besten geben Sie hier 4G physischen Speicher an. Wenn nur 2G vorhanden sind, kann es nicht normal gestartet werden. Nach etwa acht Minuten wird es wie folgt sein

Der Standardbenutzername ist root. Hier müssen Sie ein neues Passwort festlegen. Das neue Passwort sollte mindestens 8 Zeichen lang sein und kann auf qwerasdf gesetzt werden. Nach der Aktualisierung des Passworts können Sie sich mit dem root-Benutzernamen und dem Passwort qwerasdf anmelden.

Erstellen Sie ein privates Projekt Java-Demo

Push-Code in das Java-Demo-Repository

Installieren Sie Git auf einem anderen Computer und laden Sie das Quellcodepaket des Projekts hoch

[root@localhost ~]# yum install git -y

[root@localhost ~]# entpacken Sie tomcat-java-demo-master.zip

Git-Verzeichnis initialisieren

[root@localhost ~]# cd tomcat-java-demo-master
[root@localhost tomcat-java-demo-master]# git init
Leeres Git-Repository in /root/tomcat-java-demo-master/.git/ initialisiert

In diesem Git-Verzeichnis werden einige Git-bezogene Daten konfiguriert. Nach Abschluss der Initialisierung

[root@localhost tomcat-java-demo-master]# cd .git/
[root@localhost .git]# ls
Zweige Konfiguration Beschreibung HEAD Hooks Info Objekte Referenzen

Konfigurieren Sie die Git-Konfigurationsdatei

Dieser Befehl schreibt die Adresse von gitlab in die Konfigurationsdatei .git/config

[root@localhost tomcat-java-demo-master]# git remote add origin http://192.168.179.100:9999/root/java-demo.git
 
[root@localhost tomcat-java-demo-master]# cat .git/config Sie können sehen, dass die Gitlab-Adresse eingetragen ist. Wenn Sie den Code später übermitteln, lesen Sie die Konfigurationsdatei [core]
 Repositoryformatversion = 0
 Dateimodus = true
 bare = falsch
 logallrefupdates = true
[entfernter "Ursprung"]
 URL = http://192.168.179.100:9999/root/java-demo.git
 holen = +refs/heads/*:refs/remotes/origin/*

Dies stellt alles dar und übermittelt das aktuelle Codeverzeichnis an den temporären Speicherbereich.

[root@localhost tomcat-java-demo-master]# git add .
[root@localhost tomcat-java-demo-master]# ls
db Dockerfile LIZENZ pom.xml README.md src

Senden Sie an das aktuelle Git-Repository, da dies selbst ein Git-Repository ist (das lokale Repository ist auch ein Git-Repository).

[root@localhost tomcat-java-demo-master]# git commit -m 'alle'

Push zum Remote-Warehouse. Dadurch wird die vorherige Konfigurationsdatei gelesen.

[root@localhost tomcat-java-demo-master]# git push herkunft master
Benutzername für 'http://192.168.179.100:9999': root
Passwort für „http://[email protected]:9999“: 
Objekte zählen: 179, fertig.
Objekte komprimieren: 100 % (166/166), fertig.
Schreiben von Objekten: 100 % (179/179), 1,12 MiB | 0 Bytes/s, fertig.
Gesamt 179 (Delta 4), wiederverwendet 0 (Delta 0)
remote: Deltas auflösen: 100 % (4/4), fertig.
Zu http://192.168.179.100:9999/root/java-demo.git
 * [neuer Zweig] Master -> Master

Bereitstellen von Jenkins

[root@localhost jenkins]# ls
apache-maven-3.5.0-bin.tar.gz jdk-8u45-linux-x64.tar.gz
[root@localhost jenkins]# tar xf apache-maven-3.5.0-bin.tar.gz;tar xf jdk-8u45-linux-x64.tar.gz
[root@localhost jenkins]# mv jdk1.8.0_45 /usr/local/jdk
[root@localhost jenkins]# mv apache-maven-3.5.0 /usr/local/maven

Der Zweck dieser beiden Toolkits besteht darin, Jenkins die Verwendung zu ermöglichen. Jenkins wird mithilfe von Containern bereitgestellt, sodass die beiden Umgebungen auf dem Hostcomputer in sie eingebunden werden können. Um das Maven JDK zu mounten.

Da wir das Image in Jenkins erstellen müssen, müssen wir Docker Build verwenden, sodass Docker in Docker vorhanden ist, d. h. Docker in Jenkins erstellen. Es ist nicht erforderlich, zu lernen, wie Docker im Container installiert wird. Sie können die Befehle und Sockets des Hosts direkt in den Container einbinden und die Docker-Befehle direkt im Container verwenden.

-v bedeutet, dass Jenkins-Daten im Verzeichnis gespeichert werden. Jenkins speichert offiziell alle von Jenkins generierten Datendateien in

/var/jenkins_home

Verzeichnis, Sie müssen also nur dieses Verzeichnis beibehalten. Selbst wenn der Jenkins-Container gelöscht wird, können die Daten noch wiederhergestellt werden.

Das verwendete Image ist die neueste Version, ein langfristig gepflegtes Image

docker run -d --name jenkins -p 80:8080 -p 50000:50000 -u root \
  -v /opt/jenkins_home:/var/jenkins_home \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /usr/bin/docker:/usr/bin/docker \
  -v /usr/local/maven:/usr/local/maven \
  -v /usr/local/jdk:/usr/local/jdk \
  -v /etc/lokaleZeit:/etc/lokaleZeit \
  --restart=immer \
  --name jenkins jenkins/jenkins
 
[root@localhost jenkins]# docker ps
CONTAINER ID BILD BEFEHL ERSTELLT STATUS PORTS NAMEN
566d2ec85fe0 jenkins/jenkins "/sbin/tini -- /usr/…" vor 3 Minuten Vor 3 Minuten 0.0.0.0:50000->50000/tcp, 0.0.0.0:80->8080/tcp jenkins

Port 5000 ist der Master-Slave-Port

[root@localhost jenkins]# docker logs 566d2ec85fe0 Protokolle anzeigen

Klicken Sie, um die Plugin-Installation auszuwählen. Wählen Sie hier „Es sind keine Plugins installiert“ aus. Installieren Sie zuerst Jenkins und installieren Sie dann die Plugins, die Sie benötigen.

Konzepte der Jenkins-Pipeline

• Jenkins Pipeline ist ein Satz von Plugins, der Integration und kontinuierliche Bereitstellungspipelines in Jenkins unterstützt;

• Pipeline modelliert einfache bis komplexe Transportpipelines durch spezifische Syntax;

• Deklarativ: Befolgt die gleiche Syntax wie Groovy. Rohrleitung { }

• Scripting: unterstützt die meisten Funktionen von Groovy und ist außerdem ein sehr ausdrucksstarkes und flexibles Tool. Knoten { }

• Die Definition einer Jenkins-Pipeline wird in eine Textdatei namens Jenkinsfile geschrieben

Zuerst müssen Sie das Pipeline-Plugin installieren und dann den Text schreiben, um die Pipeline zu modellieren. Jetzt verwenden wir hauptsächlich deklarative Syntax. Wie sieht die Textdatei aus?

Diese Datei teilt Jenkins mit, was zu tun ist. Eine große Phase wird in viele kleine Phasen unterteilt. Diese Phasen werden in Pipelines unterteilt und diese Phasen bilden die Pipeline. Führen Sie die Ausführung der Reihe nach von oben nach unten aus, bis sie abgeschlossen ist.

Das Schreiben einer PipeLine erfolgt in etwa wie folgt

Nach der Implementierung der Pipeline gibt es einen Fall

Diese Vorlage gibt jede Schrittvorlage entsprechend jedem Schritt der Pipeline aus. Beispielsweise wie lange es gedauert hat und das Protokoll. Dadurch lässt sich das Problem leicht lokalisieren und bequem anzeigen.

Installation des Jenkins-Pipeline-Plugins und Pipeline-Nutzung

Die Installation von Plugins ist sehr langsam. Wie kann ich das beschleunigen? Wenn Jenkins das Plug-In herunterlädt, gibt es einige Quellen. Sie können die inländische Quelle ändern. Es ist eigentlich sinnlos, sie im erweiterten Plug-In zu ändern.

[root@localhost jenkins]# cd /opt/jenkins_home/
[root@localhost jenkins_home]# ls
config.xml nodeMonitors.xml
copy_reference_file.log-Knoten
hudson.model.UpdateCenter.xml-Plugins
Identität.Schlüssel.enc geheimer Schlüssel
jenkins.install.InstallUtil.lastExecVersion secret.key.nicht-so-geheim
jenkins.install.UpgradeWizard.state Geheimnisse
jenkins.model.JenkinsLocationConfiguration.xml-Aktualisierungen
jenkins.telemetry.Correlator.xml Benutzerinhalt
Jobs Benutzer
protokolliert Krieg
[root@localhost jenkins_home]# cd-Updates/
[root@localhost-Updates]# pwd
/opt/jenkins_home/updates
 
[root@localhost-Updates]# ls

default.json schreibt tatsächlich die Quelle des Plugins hudson.tasks.Maven.MavenInstaller und verwendet sed, um es zu ändern

sed -i 's/http:\/\/updates.jenkins-ci.org\/download/https:\/\/mirrors.tuna.tsinghua.edu.cn\/jenkins/g' default.json && \

sed -i 's/http:\/\/www.google.com/https:\/\/www.baidu.com/g' default.json

Wechseln Sie zur Tsinghua-Quelle und starten Sie neu, damit die Änderungen wirksam werden

[root@localhost-Updates]# Docker startet Jenkins neu

Jenkins

Installieren Sie sowohl Git als auch Pipeline. Es ist in Ordnung, wenn einige der Installationen fehlschlagen, solange der Kernschlüssel installiert ist.

Nach dem Ersetzen der Plugin-Quelle ist die Installation des Plugins deutlich schneller geworden. Sie können sehen, dass es für das neue Projekt eine zusätzliche Pipeline-Option gibt. Wählen Sie hier Pipeline Build.

Pipeline
  Agent beliebig
 
  Stufen {
    Stufe('1. Code abrufen') {
      Schritte {
        echo 'Code abrufen'
      }
    }
        Stufe('2. Code Code Code kompilieren') {
      Schritte {
        echo 'kompilieren'
      }
    }
        stage('3. Code-Bereitstellung') {
      Schritte {
        echo 'bereitstellen'
      }
    }
  }
}

Sie können das Zeichen sehen

Hier ist die Konsolenausgabe. Sie können auch angeben, dass der Build ab einem bestimmten Stadium ausgeführt werden soll.

Als Nächstes verwenden wir eine Pipeline, um das Prozessdesign abzuschließen.

Ziehen Sie den Code aus Git und erstellen Sie das Image. Zum Hafen pushen und dann im Docker bereitstellen. Dieses Skript kann wiederverwendet werden

#!/usr/bin/env groovy
 
def-Registrierung = "reg.harbor.com"
def-Projekt = "Willkommen"
def App-Name = "Demo"
def image_name = "${registry}/${project}/${app_name}:${Branch}-${BUILD_NUMBER}"
def git_address = "http://192.168.179.100:9999/root/java-demo.git"
def docker_registry_auth = "c91491d9-91cd-4248-96c8-fc8cc00f7db4"
def git_auth = "86ebc99d-d3fc-4e6e-b938-db1f5a1f3642"
 
Pipeline
  Agent beliebig
  Stufen {
    Stufe('Code abrufen'){
      Schritte {
       Kasse([$Klasse: 'GitSCM', Zweige: [[Name: '${Branch}']], Benutzer-RemoteConfigs: [[AnmeldeinformationenId: "${git_auth}", URL: "${git_address}"]]])
      }
    }
 
    stage('Codekompilierung'){
      Schritte {
       sch """
        JAVA_HOME=/usr/local/jdk
        PATH=$JAVA_HOME/bin:/usr/local/maven/bin:$PATH
        mvn sauberes Paket -Dmaven.test.skip=true
        """ 
      }
    }
 
    stage('Image erstellen'){
      Schritte {
        mitAnmeldeinformationen([BenutzernamePasswort(AnmeldeinformationenID: "${docker_registry_auth}", Passwortvariable: 'Passwort', Benutzernamevariable: 'Benutzername')]) {
        sch """
         Echo '
          VON ${registry}/library/tomcat:v1
          LABEL meister lizhenliang
          RUN rm -rf /usr/local/tomcat/webapps/*
          HINZUFÜGEN von target/*.war /usr/local/tomcat/webapps/ROOT.war
         ' > Docker-Datei
         docker build -t ${image_name} .
         Docker-Login -u ${Benutzername} -p '${Passwort}' ${Registrierung}
         Docker Push ${image_name}
        """
        }
      } 
    }
 
    stage('in Docker bereitstellen'){
      Schritte {
       sch """
       docker rm -f tomcat-java-demo |true
       Docker-Container ausführen -d --name tomcat-java-demo -p 88:8080 ${image_name}
       """
      }
    }
  }
}

Sie sehen, dass Sie hier aufgefordert werden, die Filiale einzugeben.

Parameterisierter Build, Variablennamen können in Shell-Skripten oder Pipelines referenziert werden

      Schritte {
        echo '${Branch}'
      }

Erstellen Sie Harbor-Anmeldeinformationen. Das heißt, um mit Jenkin auf das Docker Harbor-Warehouse zuzugreifen, müssen Sie den Benutzernamen und das Kennwort kennen

Sie können sehen, dass es eine zusätzliche Anmeldeinformation c91491d9-91cd-4248-96c8-fc8cc00f7db4 gibt. Die Anmeldeinformation ist im Pipeline-Skript def docker_registry_auth = "c91491d9-91cd-4248-96c8-fc8cc00f7db4" definiert. Dies ist die Anmeldeinformation von Jenkins

Sie benötigen außerdem die Git-Anmeldeinformationen des Plugins 86ebc99d-d3fc-4e6e-b938-db1f5a1f3642. Definieren Sie def git_auth = "86ebc99d-d3fc-4e6e-b938-db1f5a1f3642" in der Pipeline.

Einige Anweisungen in Pipeline können automatisch generiert werden, z. B. das Generieren von Pull-Code

Kennen Sie einfach den allgemeinen Rahmen der Pipeline und setzen Sie ihn ein

Kasse ([$-Klasse: 'GitSCM', Zweige: [[Name: '*/master']], doGenerateSubmoduleConfigurations: false, Erweiterungen: [], SubmoduleCfg: [], Benutzer-RemoteConfigs: [[AnmeldeinformationenId: '86ebc99d-d3fc-4e6e-b938-db1f5a1f3642', URL: 'http://192.168.179.100:9999/root/java-demo.git']]])

Ziehen Sie das kompilierte War-Paket und fügen Sie es in das Umgebungsabbild ein

Konfigurieren Sie nun die Maven-Quelle

Heruntergeladen: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-war-plugin/3.1.0/maven-war-plugin-3.1.0.jar (91 kB bei 5,3 kB/s)

Herunterladen: https://repo.maven.apache.org/maven2/org/springframework/boot/spring-boot-starter-web/2.0.1.RELEASE/spring-boot-starter-web-2.0.1.RELEASE.pom

Sie können diese Dinge in der Hintergrundausgabe sehen. Beim Kompilieren und Erstellen ist die Maven-Quelle das Standardnetzwerk, das relativ langsam ist. Jetzt müssen wir die Quelle ändern, um sicherzustellen, dass die Pull-Geschwindigkeit schneller ist. Ändern Sie sie auf dem Hostcomputer, der die Quelle definiert, aus der das entsprechende Abhängigkeitspaket gezogen werden soll

[root@localhost ~]# vim /usr/local/maven/conf/settings.xml 
  <Spiegel>
   <id>zentral</id>
   <mirrorOf>zentral</mirrorOf>
   <name>aliyun-Experte</name>
   <url>https://maven.aliyun.com/repository/public</url>
  </Spiegel>

Nach der Änderung müssen Sie den Container nicht neu starten und direkt neu erstellen. Sie können das erstellte Paket sehen

[root@localhost ~]# ls /opt/jenkins_home/workspace/test-pipeline/target/ Klassen generierte Quellen ly-simple-tomcat-0.0.1-SNAPSHOT ly-simple-tomcat-0.0.1-SNAPSHOT.war Maven-Archiver Maven-Status

Der Job speichert Datenquelleninformationen

[root@localhost ~]# ls /opt/jenkins_home/jobs/

Test, Test-Pipeline

Wenn Sie auf anderen Docker-Hosts bereitstellen müssen, können Sie den SSH-Befehl des SSH-Plugins verwenden oder Ansible verwenden, um den Docker-Befehl auf einem anderen Computer zu starten und auszuführen, um einen Container zu erstellen.

Nicht zum Thema

Wenn Ihr Harbor eine HTTPS-Authentifizierung bereitstellt, kopieren Sie das Zertifikat bitte in das entsprechende Verzeichnis auf Ihrem Jenkins-Host. Stellen Sie sicher, dass sich der Jenkins-Host beim Docker Harbor-Warehouse anmelden kann

[root@localhost ~]# mkdir -p /etc/docker/certs.d/reg.harbor.com
[root@localhost ~]# ls
anaconda-ks.cfg reg.harbor.com.pem
 
[root@localhost ~]# cp reg.harbor.com.pem /etc/docker/certs.d/reg.harbor.com/reg.harbor.com.crt
 
[root@localhost ~]# cat /etc/hosts
127.0.0.1 lokaler Host lokaler Host.lokale Domäne lokaler Host4 lokaler Host4.lokale Domäne4
::1 lokaler Host lokaler Host.lokale Domäne lokaler Host6 lokaler Host6.lokale Domäne6
192.168.179.102 reg.harbor.com
 
[root@localhost ~]# Docker-Login reg.harbor.com
Authentifizierung mit vorhandenen Anmeldeinformationen...
WARNUNG! Ihr Passwort wird unverschlüsselt in /root/.docker/config.json gespeichert.
Konfigurieren Sie einen Credential Helper, um diese Warnung zu entfernen. Siehe
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
 
Anmeldung erfolgreich

Der obige Artikel über Docker Gitlab+Jenkins+Harbor zum Erstellen einer dauerhaften Plattformoperation ist der gesamte Inhalt, den der Herausgeber mit Ihnen teilt. Ich hoffe, er kann Ihnen als Referenz dienen. Ich hoffe auch, dass Sie 123WORDPRESS.COM unterstützen.