Hur man installerar och konfigurerar GoCD på CentOS 7

GoCD är ett system för kontinuerlig leverans och automatisering med öppen källkod. Det låter dig modellera komplexa arbetsflöden med hjälp av dess parallella och sekventiella exekvering. Dess värdeströmskarta låter dig enkelt visualisera ett komplext arbetsflöde. GoCD låter dig enkelt jämföra två versioner och distribuera vilken version av programmet du vill ha. GoCD-ekosystemet består av GoCD-server och GoCD-agent. GoCD ansvarar för att kontrollera allt som att köra det webbaserade användargränssnittet och hantera och tillhandahålla jobb till agenten. Go-agenter är ansvariga för att köra jobben och implementeringarna.

Förutsättningar

• En Vultr CentOS 7-serverinstans med minst 1 GB RAM.
• En sudo-användare .
• Ett domännamn pekade mot servern.

För den här handledningen kommer vi att använda 192.168.1.1som den offentliga IP-adressen och gocd.example.comsom domännamnet pekade mot Vultr-instansen. Se till att ersätta alla förekomster av exemplets domännamn och IP-adress med den faktiska.

Uppdatera ditt bassystem med hjälp av guiden Hur man uppdaterar CentOS 7 . När ditt system har uppdaterats, fortsätt att installera Java.

Installera Java

GoCD kräver Java version 8 och stöder både Oracle Java och OpenJDK. I den här handledningen kommer vi att installera Java 8 från OpenJDK.

OpenJDK kan enkelt installeras, eftersom paketet är tillgängligt i standardförrådet YUM.

sudo yum -y install java-1.8.0-openjdk-devel

Om Java är korrekt installerat kommer du att kunna verifiera dess version.

java -version

Du kommer att få en liknande utdata som följande text.

[user@vultr ~]$ java -version
openjdk version "1.8.0_151"
OpenJDK Runtime Environment (build 1.8.0_151-b12)
OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)

Innan vi kan gå vidare måste vi ställa in variablerna JAVA_HOMEoch JRE_HOMEmiljö. Hitta den absoluta sökvägen för den körbara Java-filen i ditt system.

readlink -f $(which java)

Följande text kommer att matas ut till din terminal.

[user@vultr ~]$ readlink -f $(which java)
/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-5.b12.el7_4.x86_64/jre/bin/java

Nu, ställa in JAVA_HOMEoch JRE_HOMEmiljövariabler enligt sökvägen till Java-katalogen.

echo "export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-5.b12.el7_4.x86_64" >> ~/.bash_profile
echo "export JRE_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-5.b12.el7_4.x86_64/jre" >> ~/.bash_profile

Obs: Se till att du använder Java-sökvägen som erhållits på ditt system. Sökvägen som används i denna handledning kan ändras när en ny version av Java 8 släpps.

Kör bash_profilefilen.

source ~/.bash_profile

Nu kan du köra echo $JAVA_HOMEkommandot för att säkerställa att miljövariabeln är inställd.

[user@vultr ~]$ echo $JAVA_HOME
/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.151-1.b12.el7_4.x86_64

Installera GoCD

GoCD är skrivet i Java, därför är Java det enda beroendet för att köra GoCD. GoCD kan installeras med hjälp av YUM. Installera dess officiella arkiv i systemet.

sudo curl https://download.gocd.org/gocd.repo -o /etc/yum.repos.d/gocd.repo

Installera GoCD-servern i ditt system.

sudo yum install -y go-server

Starta GoCD och låt den starta automatiskt vid uppstart.

sudo systemctl start go-server
sudo systemctl enable go-server

Innan vi kommer åt GoCD-instrumentpanelen, låt oss skapa en ny katalog för att lagra artefakterna. Artefakter kan lagras på samma disk som operativsystemet och applikationerna är installerade på. Alternativt kan du använda en dedikerad disk eller blocklagringsenhet för att lagra artefakterna.

Om du vill använda samma disk för att lagra artefakterna, skapa bara en ny katalog och ange äganderätten till GoCD-användaren.

sudo mkdir /opt/artifacts
sudo chown -R go:go /opt/artifacts

Konfigurera blocklagring

GoCD-programvaran rekommenderar att du använder en extra partition eller enhet för att lagra artefakterna. I en kontinuerlig integrations- och leveransplattform genereras artefakter väldigt ofta. Diskutrymmet minskar med tiden när nya artefakter kontinuerligt genereras. I något skede kommer ditt system att ta slut på ledigt diskutrymme och tjänsterna som körs på ditt system kommer att misslyckas. För att lösa det här problemet kan du bifoga en ny Vultr-blocklagringsenhet för att lagra artefakterna. Om du fortfarande vill lagra artefakter på samma enhet, hoppa till avsnittet "Setup Firewall".

Distribuera en ny blocklagringsenhet och anslut den till din GoCD-serverinstans. Skapa nu en ny partition på blocklagringsenheten.

sudo parted -s /dev/vdb mklabel gpt
sudo parted -s /dev/vdb unit mib mkpart primary 0% 100%

Skapa filsystemet på den nya disken.

sudo mkfs.ext4 /dev/vdb1

Montera blocklagringsenheten.

sudo mkdir /mnt/artifacts
sudo cp /etc/fstab /etc/fstab.backup
echo "
/dev/vdb1 /mnt/artifacts ext4 defaults,noatime 0 0" | sudo tee -a /etc/fstab
sudo mount /mnt/artifacts

Kör nu dfoch du kommer att se den nya blocklagringsenheten monterad på /mnt/artifacts.

[user@vultr ~]$ df
Filesystem     1K-blocks    Used Available Use% Mounted on
/dev/vda1       20616252 6313892  13237464  33% /

...
/dev/vdb1       10188052   36888   9610596   1% /mnt/artifacts

Ge GoCD-användaren äganderätten till katalogen.

sudo chown -R go:go /mnt/artifacts

Installera brandvägg

Ändra brandväggskonfigurationen för att tillåta portar 8153och 8154genom brandväggen. Port 8153lyssnar efter osäkra anslutningar och port 8154för säkrade anslutningar.

sudo firewall-cmd --zone=public --add-port=8153/tcp --permanent
sudo firewall-cmd --zone=public --add-port=8154/tcp --permanent
sudo firewall-cmd --reload

Nu kan du komma åt GoCD-instrumentpanelen på http://192.168.1.1:8153. För att komma åt GoCD-instrumentpanelen på en säker anslutning, gå till https://192.168.1.1:8154. Du kommer att få ett felmeddelande som visar att certifikaten inte är giltiga. Du kan lugnt ignorera felet eftersom certifikaten är självsignerade. Av säkerhetsskäl bör du alltid använda instrumentpanelen över en säker anslutning.

Innan du skapar en ny pipeline, navigera till " Admin >> Server Configuration" från det övre navigeringsfältet.

Ange webbadressen till din osäkra webbplats i Site URLfältet " " och säkrad webbplats i Secure Site URLfältet " ".

Ange sedan din SMTP-serverinformation för att skicka e-postmeddelanden från GoCD.

Ange slutligen sökvägen till platsen där du vill lagra artefakterna. Om du har valt att lagra artefakterna på samma disk som operativsystemet anger du /opt/artifacts; om du har valt att ansluta en blocklagringsenhet kan du ange /mnt/artifacts.

Du kan också konfigurera GoCD för att automatiskt ta bort de gamla artefakterna. Konfigurera nästa alternativ enligt din diskstorlek. Alternativet för automatisk radering tar dock inte en säkerhetskopia av dina gamla artefakter. För att manuellt ta en säkerhetskopia och sedan ta bort de gamla artefakterna, inaktivera automatisk radering genom att välja Neveralternativet " Auto delete old artifacts" för alternativet " ".

Du måste starta om GoCD-servern så att de nya ändringarna tillämpas.

sudo systemctl restart go-server

Ställ in autentisering

Som standard är GoCD-instrumentpanelen inte konfigurerad för att använda någon form av autentisering, men den stöder autentisering med hjälp av en lösenordsfil och LDAP. I den här handledningen kommer vi att ställa in lösenordsbaserad autentisering.

Obs : Konfigurera autentisering är ett valfritt steg, men det rekommenderas starkt för offentliga inför servrar, såsom Vultr.

Installera Apache-verktyg så att vi kan använda htpasswdkommandot för att skapa en krypterad lösenordsfil.

sudo yum -y install httpd-tools

Skapa en lösenordsfil med htpasswdkommandot med Bcrypt-kryptering.

sudo htpasswd -B -c /etc/go/passwd_auth goadmin

Ange lösenordet för användaren två gånger. Du kommer att se följande utdata.

[user@vultr ~]$ sudo htpasswd -B -c /etc/go/passwd_auth goadmin
New password:
Re-type new password:
Adding password for user goadmin

Du kan lägga till så många användare som du vill med samma kommando ovan, men genom att ta bort -calternativet. Det -calternativet kommer att ersätta den befintliga filen, som ersätter gamla användare med den nya användaren.

sudo htpasswd -B /etc/go/passwd_auth gouser1

Sedan har vi skapat lösenordsfilen, gå till GoCD-instrumentpanelen igen. Navigera till " Admin >> Security >> Authorization Configurations" från det övre navigeringsfältet. Klicka på Addknappen och ange ett ID. Välj " Password File Authentication Plugin for GoCD" för plugin-ID och dirigera sökvägen till lösenordsfilen. Klicka nu på Check Connectionknappen " " för att verifiera att GoCD kan använda lösenordsfilen för autentisering.

Slutligen, spara autentiseringsmetoden. Ladda om instrumentpanelen så loggar den automatiskt ut dig. Du kommer att se en inloggningsskärm nu. Logga in med de inloggningsuppgifter som skapats tidigare.

Du måste marknadsföra administratörsanvändaren manuellt, annars kommer alla användare att ha administratörsbehörighet. Navigera till " Admin >> User Summary" från det övre navigeringsfältet.

Välj nu administratörsanvändaren du har skapat och klicka på Rolesrullgardinsmenyn " ". Befordra användaren till den enda administratören genom att Go System Administratormarkera kryssrutan " ".

För att lägga till användare i GoCD som skapats i lösenordsfilen, klicka på ADDknappen " " och sök efter användaren för att lägga till dem. Användare läggs också automatiskt till i GoCD-instrumentpanelen vid sin första inloggning. För att användare ska kunna logga in måste de naturligtvis läggas till i lösenordsfilen som vi har skapat tidigare.

Säkra GoCD med Let's Encrypt SSL

Som standard lyssnar GoCD på portar 8153och 8154på säkra anslutningar. Även om porten 8154ger en säker anslutning till applikationen, visar den också webbläsarfel eftersom den använder ett självsignerat certifikat. I det här avsnittet av handledningen kommer vi att installera och säkra Nginx med Let's Encrypt gratis SSL-certifikat. Nginx-webbservern kommer att fungera som en omvänd proxy för att vidarebefordra inkommande förfrågningar till GoCD:s HTTPslutpunkt.

Installera Nginx.

sudo yum -y install nginx

Starta Nginx och låt den starta automatiskt vid uppstart.

sudo systemctl start nginx
sudo systemctl enable nginx

Installera Certbot, som är klientapplikationen för Let's Encrypt CA.

sudo yum -y install certbot

Before you can request certificates, you will need to allow ports 80 and 443, or standard HTTP and HTTPS services, through the firewall. Also, remove port 8153, which listens to the unsecured connections.

sudo firewall-cmd --zone=public --add-service=http --permanent
sudo firewall-cmd --zone=public --add-service=https --permanent
sudo firewall-cmd --zone=public --remove-port=8153/tcp --permanent
sudo firewall-cmd --reload

Note: To obtain certificates from Let's Encrypt CA, the domain for which the certificates are to be generated must be pointed towards the server. If not, make the necessary changes to the DNS records of the domain and wait for the DNS to propagate before making the certificate request again. Certbot checks the domain authority before providing the certificates.

Generate the SSL certificates.

sudo certbot certonly --webroot -w /usr/share/nginx/html -d gocd.example.com

The generated certificates are likely to be stored in /etc/letsencrypt/live/gocd.example.com/. The SSL certificate will be stored as fullchain.pem and private key will be stored as privkey.pem.

Let's Encrypt certificates expire in 90 days, so it is recommended to set up auto-renewal of the certificates using cron jobs.

Open the cron job file.

sudo crontab -e

Add the following line to the end of the file.

30 5 * * * /usr/bin/certbot renew --quiet

The above cron job will run every day at 5:30 AM. If the certificate is due for expiry, it will automatically renew.

Now, change the Nginx default configuration file to take out the default_server line.

sudo sed -i 's/default_server//g' /etc/nginx/nginx.conf

Create a new configuration file for the GoCD web interface.

sudo nano /etc/nginx/conf.d/gocd.conf

Populate the file.

upstream gocd {
server 127.0.0.1:8153;
}

server {
    listen 80 default_server;
    server_name gocd.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 default_server;
    server_name gocd.example.com;

    ssl_certificate           /etc/letsencrypt/live/gocd.example.com/fullchain.pem;
    ssl_certificate_key       /etc/letsencrypt/live/gocd.example.com/privkey.pem;

    ssl on;
    ssl_session_cache  builtin:1000  shared:SSL:10m;
    ssl_protocols  TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
    ssl_prefer_server_ciphers on;

    access_log  /var/log/nginx/gocd.access.log;

location / {
        proxy_pass http://gocd;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;
        proxy_redirect off;
    }
location /go {
    proxy_pass http://gocd/go;
    proxy_http_version 1.1;
    proxy_set_header Upgrade websocket;
    proxy_set_header Connection upgrade;
    proxy_read_timeout 86400;
    }
  }

Check for errors in the new configuration file.

sudo nginx -t

If you see the following output, the configuration is error free.

[user@vultr ~]$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

If you have received some kind of error, make sure to double check the path to the SSL certificates. Restart the Nginx web server to implement the change in configuration.

sudo systemctl restart nginx

Now you can access the GoCD dashboard at https://gocd.example.com. Log in to your dashboard using the administrator credentials and navigate to "Admin >> Server Configuration" from the top navigation bar.

Set the "Site URL" and "Secure Site URL" to https://gocd.example.com. Port 8154 still needs to be accessible through the firewall so that the remote agents may connect to the server through port 8154, in case they are unable to connect through the standard HTTP port.

Installing GoCD Agent

In the GoCD continuous integration environment, GoCD agents are the workers that are responsible for the execution of all the tasks. When a change in the source is detected, the pipeline is triggered and the jobs are assigned to the available workers for execution. The agent then executes the task and reports the final status after execution.

To run a pipeline, at least one agent must to be configured. Proceed to install the GoCD agent on the GoCD server.

Since we have already imported the GoCD repository into the server, we can directly install Go Agent.

sudo yum install -y go-agent

Now, start the GoCD server and enable it to automatically start at boot time.

sudo systemctl start go-agent
sudo systemctl enable go-agent

The GoCD agent running on the localhost is automatically enabled when detected.