---
# System prepended metadata

title: Instalação e configuração de (CI/CD) GitLab em um servidor local

---

# GitLab em um servidor local - Instalação e configuração de (CI/CD)

* Instalação dos pacotes necessários
* Instalação do gitlab-ce
* Configurações de proxy e certificado SSL
* Habilitando as novas mudanças
* Configuração do firewalld
* Instalação do docker
* Autenticação entre servidores usando o sshpass
* Configuração de acesso entre servidores gitlab e nginx

## Passo 1 - Instalação dos pacotes necessários

Instale os serviços usando o seguinte comando:

`# yum -y install curl policycoreutils openssh-server openssh-clients postfix`

Inicie  ssh e postfix serviços:

```
# systemctl start sshd
# systemctl start postfix
```

Habilite os serviços para iniciar com o sistema:
```
# systemctl enable sshd
# systemctl enable postfix
```

## Passo 2 - Instalação do gitlab-ce

Primeiro vamos habilitar o repositório community edition

`curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | sudo bash`

Agora vamos instalar o gitlab-ce

`# yum -y install gitlab-ce`


## Passo 3 - Configurações de proxy e certificado SSL

Vá até o diretório onde fica localizado o arquivo:

`cd /etc/gitlab/`


Abra o arquivo usando o editor de sua preferência:

`# vim gitlab.rb`

Caso já tenha um servidor de proxy configurado edite o arquivo e adicione as seguintes configurações:

```
external_url 'https://gitlab.marquesconsult.com.br'

gitlab_rails['trusted_proxies'] = ['170.254.58.201']

nginx['redirect_https'] = false

nginx['listen_port'] = 80

nginx['listen_https'] = false

nginx['proxy_set_headers'] = {
  "X-Forwarded-Proto" => "https",
  "X-Forwarded-Ssl" => "on"
}
```

A external_url será o endereço de acesso da página do gitlab, e o restante das configurações são para usar a o protocolo https configurado no proxy.

## Passo 4 - Habilitando as novas mudanças

Após fazer as alterações execute o seguinte comando para que as alterações entrem em prática:

`# gitlab-ctl reconfigure`

## Passo 5 - Configuração do firewalld

Instale o firewalld usando o comando abaixo:

`# yum -y install firewalld`

Agora inicie habilite a inicialização automática junto com o sistema:

```
# systemctl start firewalld
# systemctl enable firewalld
```

Em seguida, libere as portas para os serviços. Abriremos portas SSH, HTTP e HTTPS para nossa configuração do GitLab. Execute os comandos firewall-cmd abaixo para abrir as portas.

```
# firewall-cmd --permanent --add-service ssh
# firewall-cmd --permanent --add-service http
# firewall-cmd --permanent --add-service https
```

Agora recarregue o firewall e verifique a configuração do firewalld. Verifique se SSH, HTTP e HTTPS estão na lista.

```
# firewall-cmd --reload
# firewall-cmd --list-all
```

## Passo 6 - Instalação do docker

Remova instalações anteriores usando os seguintes comandos:

```
$ yum remove docker \
             docker-client \
             docker-client-latest \
             docker-common \
             docker-latest \
             docker-latest-logrotate \
             docker-logrotate \
             docker-engine
```

Atualize sistema:

`yum check-update`

Instale o docker novamente:

```
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh
usermod -aG docker #you_user
```

Instaledo Docker Machine

```
base=https://github.com/docker/machine/releases/download/v0.16.0 &&
  curl -L $base/docker-machine-$(uname -s)-$(uname -m) >/tmp/docker-machine &&
  sudo mv /tmp/docker-machine /usr/local/bin/docker-machine &&
  chmod +x /usr/local/bin/docker-machine
```

Instale o Docker Compose

```
curl -L https://github.com/docker/compose/releases/download/1.25.1-rc1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
```
```

curl -L https://github.com/docker/machine/releases/download/v0.16.2/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine &&
    chmod +x /tmp/docker-machine &&
    sudo cp /tmp/docker-machine /usr/local/bin/docker-machine
```

## Passo 7 - Autenticação entre servidores usando o sshpass

O sshpass será usado para fazer a cópia protegida dos arquivos no build do servidor gitlab para o servidor remoto.

Habilite o repositório epel para instalar o sshpas

```
# yum search epel-release
# yum info epel-release
# yum install epel-release
```
Agora instale o sshpass

`yum --enablerepo=epel -y install sshpass`


## Passo 8 - Configuração de acesso entre servidores gitlab e nginx

### 8.1 Gerando as chaves SSH

Gere um par de chaves em sua máquina local com o comando:

`ssh-keygen -t rsa`

Após executar o comando apenas siga pressionando enter e confirmando as informações como padrão. Será exibido algo como:

```
Generating public/private rsa key pair.
Enter file in which to save the key (/home/andreson/.ssh/id_rsa): 
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/andreson/.ssh/id_rsa.
Your public key has been saved in /home/andreson/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:ac7iODrdkaVc8YNCf4EL04YM4NLRvlMYDW9cF38zOME andreson@elementary-os
The key's randomart image is:
+---[RSA 2048]----+
|  ooo= o..oo.    |
| o .ooB.=...Eo   |
|. o. ++= = .+ +  |
| .  o.o *.+  o o |
|     + *S. .     |
|    o =+         |
|   . o..o        |
|  . oo..         |
|  .o...          |
+----[SHA256]-----+
```

São geradas algumas chaves no diretório .ssh que fica localizado na home.
Digite o seguinte comando para verificar se as chaves foram geradas:

`ls -la $HOME/.ssh`

Será exibido algo do tipo:

```
drwx------  2 root root 4096 Jan 15 11:24 .
dr-xr-x---. 4 root root 4096 Jan 23 13:01 ..
-rw-------  1 root root  804 Jan 15 11:24 authorized_keys
-rw-------  1 root root 1679 Jan 13 11:32 id_rsa
-rw-r--r--  1 root root  408 Jan 13 11:32 id_rsa.pub
-rw-r--r--  1 root root  520 Jan 15 11:24 known_hosts
```

A chave "id_rsa" deve ser mantida apenas na sua máquina local. Já o arquivo "id_rsa.pub" deve ser carredo para a máquina remota onde serão transferidos os arquivos e executados os comandos ssh. No próximo passo vamos transferir a chave para o servidor remoto.

### 8.2 Copiando a chave pública para o servidor remoto

Para copiar a chave pública diretamente no arquivo do authorized_keys do servidor remoto use o comando abaixo:

`ssh-copy-id user@serverip`

No lugar de "user" você deve substituir pelo usuário que se conectará ao servidor para fazer a transferência de arquivos.
O serverip deverá ser substituído pelo ip da máquina remota.

Depois que o comando for executado será exibido algo parecido com:

```
The authenticity of host 'Server's IP address' can't be established.

RSA key fingerprint is ...

Are you sure you want to continue connecting (yes/no)?
```

Digite yes e pressione enter.

Será exibido uma outra mensagem em seguida como a mensagem mostrada abaixo solicitando a senha do usuário definida no comando "ssh-copy-id", na maioria das vezes é o usuário root.

```
Warning: Permanently added 'SERVER IP' (RSA) to the list of known hosts.

user@serverip's password:
```

Depois de digitar a senha e confirmar você será saudado com outra mensagem:

```
Now try logging into the machine, with "ssh 'user@serverip'", and check in:

~/.ssh/authorized_keys*

to make sure we haven't added extra keys that you weren't expecting.
```


