Configurando GlusterFS no Ubuntu 22.04 com Heketi

GlusterFS é um software de código aberto desenvolvido pela Gluster Inc e atualmente mantido pela Redhat. Ele é usado para fornecer interfaces de armazenamento de objetos, blocos e arquivos. Ele fornece armazenamento acessível e flexível para dados não estruturados e é frequentemente usado em cargas de trabalho com alto uso de dados, que incluem streaming de mídia de armazenamento em nuvem e CDN. Ele pode ser implantado no local ou na nuvem e oferece suporte a inúmeros protocolos que incluem NFS, SMB, CIFS, HTTP e FTP

Heketi pode ser usado para gerenciar o ciclo de vida dos volumes Gluster Storage, fornecendo uma interface de gerenciamento RESTful. Isso facilita a integração do GlusterFS com serviços em nuvem como Kubernetes, OpenStack Manila e OpenShift para o provisionamento dinâmico de volumes. Heketi determina automaticamente a localização dos blocos no cluster, colocando-os e suas réplicas em diferentes domínios de falha. Ele também oferece suporte a inúmeros clusters GlusterFS, tornando possível fornecer armazenamento de arquivos em rede sem limitação de um único cluster GlusterFS. Geralmente, o Heketi torna mais fácil para o administrador do sistema gerenciar ou configurar blocos, discos ou pools de armazenamento confiáveis. Este serviço gerencia todo o hardware do administrador possibilitando a localização do armazenamento sob demanda.

Hoje aprenderemos como configurar GlusterFS no Ubuntu 22.04 com Heketi

Começando

Para este guia, teremos um ambiente configurado conforme mostrado:

• 3 servidores Ubuntu 22.04 para GlusterFS
• Cada servidor possui 3 discos secundários de 10 GB conectados
• acesso sudo
• Heketi será configurado em um dos servidores

A resolução DNS pode ser configurada em /etc/hosts em cada servidor para quem não possui um servidor DNS

$ sudo vim /etc/hosts
192.168.200.90 gluster01.computingforgeeks.com  gluster01
192.168.200.91 gluster02.computingforgeeks.com  gluster02
192.168.200.92  gluster03.computingforgeeks.com  gluster03

1. Configure a sincronização de horário NTP

Antes de começarmos, é importante que a hora em todos os 3 servidores esteja sincronizada. Isso pode ser feito usando Network Time Protocol (NTP) ou o daemon Chrony.

Para conseguir isso, certifique-se de que o Chrony esteja instalado:

sudo apt -y install chrony

Inicie e ative o serviço:

sudo systemctl enable --now chronyd

Defina o fuso horário em todos os 3 servidores:

sudo timedatectl set-timezone Africa/Nairobi --adjust-system-clock
sudo timedatectl set-ntp yes

Verifique as alterações:

$ timedatectl 
               Local time: J5 2023-06-14 14:44:50 EAT
           Universal time: J5 2023-06-14 11:44:50 UTC
                 RTC time: J5 2023-06-14 11:44:50
                Time zone: Africa/Nairobi (EAT, +0300)
System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no

2. Instale GlusterFS no Ubuntu 22.04

GlusterFS existe nos repositórios padrão do Ubuntu 22.04. Isso torna a instalação muito fácil. Para instalar o GlusterFS no Ubuntu 22.04, execute o comando abaixo:

sudo apt install glusterfs-server

Depois de instalado, certifique-se de que o serviço foi iniciado e habilitado:

sudo systemctl enable --now glusterd

Veja o status do serviço:

$ systemctl status glusterd
● glusterd.service - GlusterFS, a clustered file-system server
     Loaded: loaded (/lib/systemd/system/glusterd.service; enabled; vendor preset: enabled)
     Active: active (running) since Wed 2023-06-14 14:46:22 EAT; 4s ago
       Docs: man:glusterd(8)
    Process: 14472 ExecStart=/usr/sbin/glusterd -p /var/run/glusterd.pid --log-level $LOG_LEV>
   Main PID: 14473 (glusterd)
      Tasks: 9 (limit: 4617)
     Memory: 11.0M
        CPU: 1.481s
     CGroup: /system.slice/glusterd.service
             └─14473 /usr/sbin/glusterd -p /var/run/glusterd.pid --log-level INFO

Jun 14 14:46:21 gluster01.computingforgeeks.com systemd[1]: Starting GlusterFS,

Se você tiver um firewall habilitado, permita o serviço através dele:

sudo ufw allow 24007/tcp

Assim que a instalação estiver concluída em todos os três nós, testaremos outros nós no cluster. Forme um nó gluster01 digamos, execute os comandos abaixo:

# Perform on Node 01
sudo gluster peer probe gluster02
sudo gluster peer probe gluster03

Veja o status:

sudo gluster peer status

Saída de amostra:

3. Instale o Heketi no Ubuntu 22.04

Conforme afirmado anteriormente, o Heketi será instalado em apenas um nó do cluster. Para este guia, iremos instalá-lo em gluster01. Baixe a versão mais recente do Heketi na página de lançamentos do GitHub.

Você também pode extrair o binário com o comando:

wget https://github.com/heketi/heketi/releases/download/v10.4.0/heketi-v10.4.0-release-10.linux.amd64.tar.gz

Extraia o arquivo:

for i in `ls | grep heketi | grep .tar.gz`; do tar xvf $i; done

Copie os binários extraídos para o seu PATH:

sudo cp heketi/{heketi,heketi-cli} /usr/local/bin

Agora verifique a instalação:

$ heketi --version
Heketi v10.4.0-release-10 (using go: go1.15.14)

$ heketi-cli --version
heketi-cli v10.4.0-release-10

4. Configure o Heketi no Ubuntu 22.04

Existem várias configurações que precisamos fazer antes que o Heketi possa ser usado. Primeiro, crie um usuário dedicado para Heketi:

sudo groupadd --system heketi
sudo useradd -s /sbin/nologin --system -g heketi heketi

Em seguida, prossiga e crie configurações e caminhos de dados para Heketi:

sudo mkdir -p /var/lib/heketi /etc/heketi /var/log/heketi
sudo cp heketi/heketi.json /etc/heketi

Agora podemos modificar o arquivo de configuração criado conforme desejado:

sudo vim /etc/heketi/heketi.json

No arquivo, existem diversas variáveis que podem ser modificadas, incluindo:

##Set service port##
"port": "8080"

##Set admin and use secrets##
"_jwt": "Private keys for access",
  "jwt": {
    "_admin": "Admin has access to all APIs",
    "admin": {
      "key": "jvd7df8RN7QNeKV1"
    },
    "_user": "User only has access to /volumes endpoint",
    "user": {
      "key": "lMPgdZ8NtFNj6jgk"
    }
  },

##Configure glusterfs executor##
_sshexec_comment": "SSH username and private key file information",
    "sshexec": {
      "keyfile": "/etc/heketi/heketi_key",
      "user": "root",
      "port": "22",
      "fstab": "/etc/fstab",
......
},

##database path settings
"_db_comment": "Database file name",
    "db": "/var/lib/heketi/heketi.db",
....
},

Também no arquivo, comente as linhas abaixo adicionando (_) conforme mostrado:

    "_sshexec_comment": "SSH username and private key file information",
....
      "_xfs_sw": "Optional: Specify number of data disks in the underlying RAID device",
      "_xfs_su": "Optional: Specifies a stripe unit or RAID chunk size.",
      "_gluster_cli_timeout": "Optional: Timeout, in seconds, passed to the gluster cli invocations",
      "_debug_umount_failures": "Optional: boolean to capture more details in case brick unmounting fails",

    "_kubeexec_comment": "Kubernetes configuration",
      "_xfs_sw": "Optional: Specify number of data disks in the underlying RAID device.",
      "_xfs_su": "Optional: Specifies a stripe unit or RAID chunk size.",
      "_gluster_cli_timeout": "Optional: Timeout, in seconds, passed to the gluster cli invocations",
      "_debug_umount_failures": "Optional: boolean to capture more details in case brick unmounting fails",
.....

Se você usar um usuário SSH diferente de root, certifique-se de ter configurado sem senha para sudo. Depois que as alterações desejadas forem feitas, salve o arquivo e gere as chaves SSH para o usuário fornecido, por exemplo, root:

sudo -i
ssh-keygen -f /etc/heketi/heketi_key -t rsa -N ''
chown heketi:heketi /etc/heketi/heketi_key*

Primeiro, certifique-se de que o login root seja permitido em todos os 3 servidores se estiver usando root como usuário:

$ vim /etc/ssh/sshd_config
PermitRootLogin yes

Reinicie o serviço:

sudo systemctl restart sshd

Copie a chave pública criada para todos os outros nós do GlusterFS usando o comando:

for i in gluster01 gluster02 gluster03; do
 ssh-copy-id -i /etc/heketi/heketi_key.pub root@$i
done

Verifique o acesso aos nós GlusterFS de gluster01 com a chave privada:

root@gluster01:~# ssh -i /etc/heketi/heketi_key root@gluster02
Welcome to Ubuntu 22.04 LTS (GNU/Linux 5.19.0-41-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

460 updates can be applied immediately.
255 of these updates are standard security updates.
To see these additional updates run: apt list --upgradable

Last login: Wed Jun 14 17:10:36 2023 from 192.168.200.90
root@gluster02:~# exit

Isso mostra que as chaves SSH estão funcionando conforme desejado. Saia da sessão e prossiga com as configurações abaixo.

Crie um arquivo de serviço para Heketi:

sudo vim /etc/systemd/system/heketi.service

Adicione estas linhas ao arquivo:

[Unit]
Description=Heketi Server

[Service]
Type=simple
WorkingDirectory=/var/lib/heketi
EnvironmentFile=-/etc/heketi/heketi.env
User=heketi
ExecStart=/usr/local/bin/heketi --config=/etc/heketi/heketi.json
Restart=on-failure
StandardOutput=syslog
StandardError=syslog

[Install]
WantedBy=multi-user.target

Salve o arquivo e baixe um arquivo de ambiente:

sudo wget -O /etc/heketi/heketi.env https://raw.githubusercontent.com/heketi/heketi/master/extras/systemd/heketi.env

Atribua todas as permissões necessárias ao usuário Heketi:

sudo chown -R heketi:heketi /var/lib/heketi /var/log/heketi /etc/heketi

Carregue todos os módulos do Kernel exigidos pelo Heketi:

for i in dm_snapshot dm_mirror dm_thin_pool; do
  sudo modprobe $i
done

Recarregue o daemon e inicie o serviço:

sudo systemctl daemon-reload
sudo systemctl enable --now heketi

Verifique se o serviço está ativo:

$ systemctl status heketi
● heketi.service - Heketi Server
     Loaded: loaded (/etc/systemd/system/heketi.service; enabled; vendor preset: enabled)
     Active: active (running) since Wed 2023-06-14 17:48:36 EAT; 4s ago
   Main PID: 4545 (heketi)
      Tasks: 7 (limit: 4617)
     Memory: 5.7M
        CPU: 16ms
     CGroup: /system.slice/heketi.service
             └─4545 /usr/local/bin/heketi --config=/etc/heketi/heketi.json

Jun 14 17:48:36 gluster01.computingforgeeks.com heketi[4545]: Heketi v10.4.0-release-10 (using go: go1.15.14)
Jun 14 17:48:36 gluster01.computingforgeeks.com heketi[4545]: [heketi] INFO 2023/06/14 17:48:36 Loaded mock executor
....
Jun 14 17:48:36 gluster01.computingforgeeks.com heketi[4545]: Listening on port 8080

5. Crie o arquivo de topologia Heketi

Para este guia, usaremos scripts Ansible para gerar e manter o arquivo de topologia Heketi, pois editar o arquivo JSON manualmente pode ser cansativo.

Para facilitar, instale o Ansible no seu sistema:

sudo apt update
sudo apt install software-properties-common
sudo apt-add-repository --yes --update ppa:ansible/ansible
sudo apt install ansible

Em seguida, crie uma pasta de projeto:

mkdir -p ~/projects/ansible/roles/heketi/{tasks,templates,defaults}

Agora crie o modelo para o arquivo de Topologia:

$ vim ~/projects/ansible/roles/heketi/templates/topology.json.j2
{
  "clusters": [
    {
      "nodes": [
      {% if gluster_servers is defined and gluster_servers is iterable %}
      {% for item in gluster_servers %}
        {
          "node": {
            "hostnames": {
              "manage": [
                "{{ item.servername }}"
              ],
              "storage": [
                "{{ item.serverip }}"
              ]
            },
            "zone": {{ item.zone }}
          },
          "devices": [
            "{{ item.disks | list | join ("\",\"") }}"
          ]
        }{% if not loop.last %},{% endif %}
    {% endfor %}
    {% endif %}
      ]
    }
  ]
}

Salve este arquivo e crie um arquivo de variáveis que corresponda aos valores definidos:

vim ~/projects/ansible/roles/heketi/defaults/main.yml

Adicione as linhas abaixo, substituindo corretamente quando necessário:

---
# GlusterFS nodes
gluster_servers:
  - servername: gluster01
    serverip: 192.168.200.90
    zone: 1
    disks:
      - /dev/sdb
      - /dev/sdc
      - /dev/sdd
  - servername: gluster02
    serverip: 192.168.200.91
    zone: 1
    disks:
      - /dev/sdb
      - /dev/sdc
      - /dev/sdd
  - servername: gluster03
    serverip: 192.168.200.92
    zone: 1
    disks:
      - /dev/sdb
      - /dev/sdc
      - /dev/sdd

Crie uma tarefa Ansible:

vim ~/projects/ansible/roles/heketi/tasks/main.yml

No arquivo, forneça o conteúdo abaixo:

---
- name: Copy heketi topology file
  template:
    src: topology.json.j2
    dest: /etc/heketi/topology.json

- name: Set proper file ownership
  file:
   path:  /etc/heketi/topology.json
   owner: heketi
   group: heketi

Crie o arquivo do manual do Ansible:

vim ~/projects/ansible/heketi.yml

Adicione estas linhas ao arquivo:

---
- name: Generate Heketi topology file and copy to Heketi Server
  hosts: gluster01
  become: yes
  become_method: sudo
  roles:
    - heketi

Crie o arquivo hosts:

$ vim ~/projects/ansible/hosts
gluster01

Navegue até o diretório:

cd ~/projects/ansible

Veja tudo o que foi criado:

$ tree
.
├── heketi.yml
├── hosts
└── roles
    └── heketi
        ├── defaults
        │   └── main.yml
        ├── tasks
        │   └── main.yml
        └── templates
            └── topology.json.j2

5 directories, 5 files

Agora execute o playbook Ansible usando o comando:s

ansible-playbook -i hosts --user myuser --ask-pass --ask-become-pass heketi.yml

Como alternativa, você pode usar o usuário root ou o usuário sudo sem senha com o comando:

ansible-playbook -i hosts --user myuser heketi.yml

Saída de amostra:

Agora você terá um arquivo de topologia gerado conforme mostrado:

$ cat /etc/heketi/topology.json 
{
  "clusters": [
    {
      "nodes": [
                    {
          "node": {
            "hostnames": {
              "manage": [
                "gluster01"
              ],
              "storage": [
                "192.168.200.90"
              ]
            },
            "zone": 1
          },
          "devices": [
            "/dev/sdb","/dev/sdc","/dev/sdd"
          ]
        },            {
          "node": {
            "hostnames": {
              "manage": [
                "gluster02"
              ],
              "storage": [
                "192.168.200.91"
              ]
            },
            "zone": 1
          },
          "devices": [
            "/dev/sdb","/dev/sdc","/dev/sdd"
          ]
        },            {
          "node": {
            "hostnames": {
              "manage": [
                "gluster03"
              ],
              "storage": [
                "192.168.200.92"
              ]
            },
            "zone": 1
          },
          "devices": [
            "/dev/sdb","/dev/sdc","/dev/sdd"
          ]
        }              ]
    }
  ]
}

6. Carregue o arquivo de topologia Heketi

Depois que o arquivo de topologia for criado com as etapas acima, podemos carregá-lo e usá-lo no Heketi. Para carregá-lo usando o CI, execute o comando com a sintaxe abaixo

heketi-cli topology load --user admin --secret <heketi_admin_secret> --json=/etc/heketi/topology.json

Substitua o heketi_admin_secret, por exemplo:

heketi-cli topology load --user admin --secret jvd7df8RN7QNeKV1 --json=/etc/heketi/topology.json

Saída de amostra:

Agora exporte as variáveis:

$ vim ~/.bashrc
export HEKETI_CLI_SERVER=http://heketiserverip:8080
export HEKETI_CLI_USER=admin
export HEKETI_CLI_KEY="Adminsecret"

Fonte do perfil:

source ~/.bashrc

Agora visualize o cluster:

$ heketi-cli cluster list
Clusters:
Id:e36f3593c6abde17ff69665043765e17 [file][block]

Mostre os nós disponíveis:

$ heketi-cli node list
Id:111dcab88510035789f3551a359e27fe	Cluster:e36f3593c6abde17ff69665043765e17
Id:3649b21cb354e55c3588868ddfa7ff92	Cluster:e36f3593c6abde17ff69665043765e17
Id:b9dbcd4773319d28e3f265d6ab6b52b6	Cluster:e36f3593c6abde17ff69665043765e17

Você também pode usar o comando abaixo para visualizar os nós:

$ sudo gluster pool list
UUID					Hostname 	State
44c4384a-313b-4726-87c7-89622250ab83	gluster02	Connected 
d1f8f291-f2cd-4a8b-8b26-91243d192ecf	gluster03	Connected 
d1f8f291-f2cd-4a8b-8b26-91243d192ece	localhost	Connected 

Veja mais detalhes do cluster

heketi-cli node info <NODE_ID>

Por exemplo:

$ heketi-cli node info 111dcab88510035789f3551a359e27fe
Node Id: 111dcab88510035789f3551a359e27fe
State: online
Cluster Id: e36f3593c6abde17ff69665043765e17
Zone: 1
Management Hostname: gluster03
Storage Hostname: 192.168.200.92
Devices:
Id:1072f75242b8f7cd32d450344c2bf9b4   Name:/dev/sdd            State:online    Size (GiB):500     Used (GiB):0       Free (GiB):500     Bricks:0       
Id:49e832b9834ec185b21960f411891292   Name:/dev/sdc            State:online    Size (GiB):500     Used (GiB):0       Free (GiB):500     Bricks:0       
Id:a8aca352fb2d742e9bda4d04e48877a9   Name:/dev/sdb            State:online    Size (GiB):500     Used (GiB):0       Free (GiB):500     Bricks:0    

Para verificar se os volumes Gluster estão funcionando conforme desejado, usaremos Heketi para criar um volume:

# heketi-cli volume create --size=1
Name: vol_e3791aa3f720f8e1e50c3d433326030f
Size: 1
Volume Id: e3791aa3f720f8e1e50c3d433326030f
Cluster Id: e36f3593c6abde17ff69665043765e17
Mount: 192.168.200.92:vol_e3791aa3f720f8e1e50c3d433326030f
Mount Options: backup-volfile-servers=192.168.200.91,192.168.200.90
Block: false
Free Size: 0
Reserved Size: 0
Block Hosting Restriction: (none)
Block Volumes: []
Durability Type: replicate
Distribute Count: 1
Replica Count: 3

Veja o volume criado:

# heketi-cli volume list
Id:e3791aa3f720f8e1e50c3d433326030f    Cluster:e36f3593c6abde17ff69665043765e17    Name:vol_e3791aa3f720f8e1e50c3d433326030f

Para visualizar a topologia, execute:

heketi-cli topology info

Agora o brinquedo pode prosseguir e usar o GlusterFS conforme desejado. Para integrá-lo ao Kubernetes, siga o auxílio fornecido aqui:

• Configure o provisionamento de volume dinâmico do Kubernetes com Heketi e GlusterFS

Existem muitos outros casos de uso, fique à vontade para explorá-los. Espero que este guia tenha sido significativo para você.

Ver mais:

• Configure o armazenamento GlusterFS com Heketi no CentOS
• Provisionamento de volume dinâmico Kubernetes e OpenShift com GlusterFS e Heketi
• Como criar e excluir volumes GlusterFS