Opcional: configurando uma instância de serviço do IBM Cloud Object Storage

Para configurar o IBM Cloud Object Storage como o armazenamento de backup padrão em seu cluster de armazenamento, crie uma instância do IBM Cloud Object Storage. Em seguida, crie um conjunto de credenciais HMAC e um segredo do Kubernetes que usem suas credenciais HMAC do Object Storage. Se você não especificar as credenciais do IBM Cloud Object Storage durante a instalação, o armazenamento de suporte padrão em seu cluster de armazenamento será criado com os PVs no cluster. É possível configurar armazenamentos auxiliares adicionais após a implementação do ODF, mas não é possível mudar o armazenamento auxiliar padrão.

Acesse o seu Red Hat OpenShift cluster.

1. Crie um espaço de nomes openshift-storage no seu cluster. Os pods do driver são implementados nesse espaço de nomes. Copie o YAML a seguir e salve-o como os-namespace.yaml na sua máquina local.

   apiVersion: v1
   kind: Namespace
   metadata:
     labels:
       openshift.io/cluster-monitoring: "true"
     name: openshift-storage
   

2. Crie o espaço de nomes openshift-storage usando o arquivo YAML que você salvou.

   oc create -f os-namespace.yaml
   

3. Verifique se o namespace foi criado.

   oc get namespaces | grep storage
   

4. Crie uma instância de serviço do IBM Cloud Object Storage.

   ibmcloud resource service-instance-create noobaa-store cloud-object-storage standard global
   

5. Crie credenciais HMAC. Anote suas credenciais.

   ibmcloud resource service-key-create cos-cred-rw Writer --instance-name noobaa-store --parameters '{"HMAC": true}'
   

6. Crie o segredo do Kubernetes chamado ibm-cloud-cos-creds no espaço de nomes openshift-storage que usa suas credenciais de HMAC do Object Storage. Ao executar o comando, especifique seu ID da chave de acesso e a chave de acesso secreta de HMAC do Object Storage. Observe que seu segredo deve ser denominado ibm-cloud-cos-creds.

   oc -n 'openshift-storage' create secret generic 'ibm-cloud-cos-creds' --type=Opaque --from-literal=IBM_COS_ACCESS_KEY_ID=<access_key_id> --from-literal=IBM_COS_SECRET_ACCESS_KEY=<secret_access_key>
   

7. Verifique se o seu segredo foi criado.

   oc get secrets -A | grep cos
   

Opcional: Configurando a criptografia usando o Hyper Protect Crypto Services

Se você desejar configurar a criptografia, crie uma instância de Hyper Protect Crypto Services ou Key Protect. Em seguida, crie uma chave raiz e um segredo do tipo “ Kubernetes ” que utilize suas credenciais do Hyper Protect Crypto Services ou Key Protect.

A IBM Cloud está mudando os serviços dedicados de gerenciamento de chave de Hyper Protect Crypto Services para Key Protect Dedicated.

Sua chave de API para Hyper Protect Crypto Services ou Key Protect deve ter as permissões mínimas necessárias a seguir:

Reader

Reader Plus

Se você estiver usando a criptografia em todo o cluster e a criptografia de classe de armazenamento, sua chave de API deverá ter as permissões necessárias a seguir:

Reader

Reader Plus

Writer

1. Crie uma instância de serviço Hyper Protect Crypto Services ou Key Protect.

2. Criar chave raiz

   • Hyper Protect Crypto Services.
   • Key Protect.

3. Depois de criar sua instância e sua chave raiz, anote o nome da instância ( Hyper Protect Crypto Services ou Key Protect ), o ID da instância, o ID da chave raiz e o endpoint público.

4. Crie um ID de serviço, chave de API e política de acesso que permita o acesso a Hyper Protect Crypto Services e Red Hat OpenShift on IBM Cloud ou Key Protect e Red Hat OpenShift on IBM Cloud. Anote a API que você criou.

Acesse o seu Red Hat OpenShift cluster.

1. Liste seus namespaces para determinar se você tem um namespace openshift-storage. Se você não tiver um namespace openshift-storage, crie-o.

   oc get namespaces | grep openshift-storage
   

   1. Crie um espaço de nomes openshift-storage no seu cluster. Os pods do driver são implementados nesse espaço de nomes. Copie o YAML a seguir e salve-o como os-namespace.yaml na sua máquina local.

       apiVersion: v1
       kind: Namespace
       metadata:
         labels:
           openshift.io/cluster-monitoring: "true"
         name: openshift-storage
       ```
   1. Crie o espaço de nomes `openshift-storage` usando o arquivo YAML que você salvou.
   ```sh {: pre}
       oc create -f os-namespace.yaml
       ```
   1. Verifique se o namespace foi criado.
   ```sh {: pre}
       oc get namespaces | grep storage
       ```
   

2. Codifique o ID de sua chave raiz e a chave de API do ID de serviço que você criou como base64.

   printf "ROOT-KEY-ID" | base64
   

   printf "SERVICE-ID-API-KEY" | base64
   

3. Crie o segredo do Kubernetes no namespace openshift-storage que usa suas credenciais do Hyper Protect Crypto Services.
   1. Salve o segredo a seguir como um arquivo YAML chamado ibm-hpcs-secret.yaml.

       apiVersion: v1
       data:
         IBM_KP_CUSTOMER_ROOT_KEY: AaAAAaZAAAAy11AAAyAAkaAaQtAAk0AAA2AzY5AjYaaa67aa # your base64 encoded root key ID
         IBM_KP_SERVICE_API_KEY: AAAaaajAAAAAncmAAaaaaAAAAdAAId1AtVjBJRU1aAAaAeTh1aEw=AaaaA # your base64 encoded API
       kind: Secret
       metadata:
         name: ibm-hpcs-secret
         namespace: openshift-storage
       type: Opaque
       ```
   1. Crie o segredo em seu cluster.
   ```sh {: pre}
       oc apply -f ibm-hpcs-secret.yaml
       ```
   

4. Verifique se o seu segredo foi criado.

   oc get secrets -A | grep ibm-hpcs-secret
   

Preparando seu cluster para uma instalação do OpenShift Data Foundation

Antes de instalar o OpenShift Data Foundation, prepare o seu cluster.

Acesse o seu Red Hat OpenShift cluster.

1. Efetue login em cada nó do trabalhador em seu cluster usando o comando oc debug e conclua as etapas a seguir.

   • Efetue login no nó do trabalhador. Substitua <worker_node_IP> pelo nome do seu nó de trabalho. Para obter os nomes dos seus nós de trabalho, execute o oc get nodes comando.

       oc debug node/<node name> -- chroot /host rm -rvf /var/lib/rook /mnt/local-storage
       ```
   - Para cada partição de disco, limpe o sistema de arquivos `xfs` no nó do trabalhador. Se você não limpar o sistema de arquivos, o OSD não será criado.
   ```sh {: pre}
       file -sL /dev/<partition>
       wipefs -a /dev/<partition>
       ```
   - Edite o arquivo `/etc/kubernetes/kubelet.conf` e altere o valor do parâmetro `EnableControllerAttachDetach` para `true`.
   ```sh {: pre}
       nano /etc/kubernetes/kubelet.conf
       ```
   - Salve e saia usando `ctrl + X`.
   
   - Reinicie o Kubelet.
   ```sh {: pre}
       systemctl restart kubelet
       ```
   - Efetue logout do nó do trabalhador.
   ```sh
       exit
       ```
   
   

2. Repita as etapas anteriores para limpar o sistema de arquivos para cada nó do trabalhador que você deseja utilizar em sua implantação do ODF.

Obtendo os detalhes do dispositivo

É possível usar a descoberta automática de disco para localizar dispositivos disponíveis para o ODF. No entanto, se você quiser especificar manualmente os dispositivos de armazenamento para o ODF, complete as etapas a seguir para recuperar os detalhes de seu dispositivo de armazenamento.

Antes de instalar o ODF, obtenha os detalhes dos discos locais em seus nós do trabalhador.

1. Efetue login em seu cluster e obtenha uma lista de nós do trabalhador disponíveis. Anote os nós do trabalhador que você deseja usar na sua implementação do OCS.

   oc get nodes
   

2. Efetue login em cada nó do trabalhador que você deseja usar para o ODF.

   oc debug node/<node-name>
   

3. Depois de implementar o pod de depuração no nó do trabalhador, execute o comando a seguir para permitir binários de host.

   chroot /host
   

4. Liste os discos disponíveis no nó do trabalhador.

   lsblk
   

5. Revise a saída de comando para obter os discos disponíveis. É possível usar apenas discos desmontados para implementações do ODF, como os discos sdc do exemplo a seguir. Observe que a capacidade de armazenamento inicial da implementação do ODF é igual ao tamanho do disco especificado como o osd-device-path. Neste exemplo, o disco sdc é desmontado e possui duas partições disponíveis: sdc1 e sdc2.

   NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
   sda      8:0    0   931G  0 disk
   |-sda1   8:1    0   256M  0 part /boot
   |-sda2   8:2    0     1G  0 part
    -sda3   8:3    0 929.8G  0 part /
   sdb      8:16   0 744.7G  0 disk
    -sdb1   8:17   0 744.7G  0 part /disk1
   sdc      8:32   0 744.7G  0 disk
   |-sdc1   8:33   0  18.6G  0 part
    -sdc2   8:34   0 260.8G  0 part
   

6. Para cada disco desmontado que você deseja usar em sua implementação, localize o ID do disco. No exemplo a seguir, o ID para a partição sdc1 é scsi-3600605b00d87b43027b3bc310a64c6c9-part1, e o ID para a partição sdc2 é scsi-3600605b00d87b43027b3bc310a64c6c9-part2.

   ls -l /dev/disk/by-id/
   

   Exemplo de saída

   total 0
   lrwxrwxrwx. 1 root root  9 Feb  9 04:15 scsi-3600605b00d87b43027b3bbb603150cc6 -> ../../sda
   lrwxrwxrwx. 1 root root 10 Feb  9 04:15 scsi-3600605b00d87b43027b3bbb603150cc6-part1 -> ../../sda1
   lrwxrwxrwx. 1 root root 10 Feb  9 04:15 scsi-3600605b00d87b43027b3bbb603150cc6-part2 -> ../../sda2
   lrwxrwxrwx. 1 root root 10 Feb  9 04:15 scsi-3600605b00d87b43027b3bbb603150cc6-part3 -> ../../sda3
   lrwxrwxrwx. 1 root root  9 Feb  9 04:15 scsi-3600605b00d87b43027b3bbf306bc28a7 -> ../../sdb
   lrwxrwxrwx. 1 root root 10 Feb  9 04:15 scsi-3600605b00d87b43027b3bbf306bc28a7-part1 -> ../../sdb1
   lrwxrwxrwx. 1 root root  9 Feb  9 04:17 scsi-3600605b00d87b43027b3bc310a64c6c9 -> ../../sdc
   lrwxrwxrwx. 1 root root 10 Feb 11 03:14 scsi-3600605b00d87b43027b3bc310a64c6c9-part1 -> ../../sdc1
   lrwxrwxrwx. 1 root root 10 Feb 11 03:15 scsi-3600605b00d87b43027b3bc310a64c6c9-part2 -> ../../sdc2
   

7. Repita as etapas anteriores com relação a cada nó do trabalhador que você deseja usar para a implementação do OpenShift Data Foundation.

8. Instale o ODF em seu cluster.