Instalando o Portworx em seu Cluster

Provisione uma instância de serviço do Portworx por meio do catálogo do IBM Cloud. Após criar a instância de serviço, a edição corporativa do Portworx mais recente (px-enterprise) será instalada em seu cluster usando o Helm. Além disso, o Stork também está instalado no seu cluster Red Hat OpenShift on IBM Cloud. O Stork é o planejador de armazenamento do Portworx. Com o Stork, você pode alojar pods junto com seus dados, além de criar e restaurar instantâneos de volumes d Portworx.

Procurando instruções sobre como atualizar ou remover o Portworx? Consulte Atualizando Portworx e Removendo Portworx.

O método de instalação padrão para Portworx Enterprise e Portworx O backup ainda não é compatível com clusters exclusivamente privados na região de Montreal. Entre em contato com o suporte da Portworx se precisar instalar o Portworx Enterprise ou o Portworx Backup em um cluster privado em Montreal. Para obter mais informações, consulte o Suporte doPortworx

Antes de Iniciar:

Para instalar o Portworx:

  1. Abra o serviço Portworx no Catálogo da IBM Cloud e complete os campos conforme a seguir:

    1. Selecione a região na qual seu cluster do Red Hat OpenShift on IBM Cloud está localizado.

    2. Revise as informações de precificação do Portworx.

    3. Insira um nome para sua instância de serviço do Portworx.

    4. Selecione o grupo de recursos no qual está o seu cluster.

    5. No campo Tag, insira o nome do cluster no qual você deseja instalar o Portworx. Depois de criar a instância de serviço Portworx, não é possível ver o cluster em que você instalou o Portworx. Para localizar o cluster com mais facilidade posteriormente, assegure-se de inserir o nome do cluster e quaisquer informações adicionais como tags.

    6. Insira uma chave de API do IBM Cloud para recuperar a lista de clusters aos quais você tem acesso. Se você não tiver uma chave de API, consulte Gerenciando chaves de API do usuário. Depois de inserir a chave de API, o campo Nome do cluster Kubernetes ou OpenShift aparece.

    7. Insira um Nome de cluster Portworx exclusivo.

    8. No menu Unidades de nuvem:

      1. Selecione Usar unidades de nuvem (apenas clusters VPC) para fornecer dinamicamente o Block Storage for VPC para Portworx. Após selecionar Usar unidades de nuvem, selecione o Nome da classe de armazenamento e o Tamanho das unidades de armazenamento de bloco que você deseja provisionar.
      2. Selecione Utilizar unidades já anexadas (Clássica, VPC ou Satellite) para usar o armazenamento de bloco que já está conectado aos seus nós do trabalhador.

    9. No menu suspenso Armazenamento de chave-valor dos metadados do Portworx, escolha o tipo de armazenamento de chave-valor que você deseja usar para armazenar metadados do Portworx. Selecione Portworx KVDB para criar automaticamente uma loja de chave-valor durante a instalação do Portworx ou selecione Databases for etcd se você desejar usar uma instância do Databases for etcd existente. Se você escolher Databases for etcd, os campos Terminais de API Etcd e Nome do segredo Etcd aparecerão.

    10. Namespace: insira o namespace no qual você deseja implementar os recursos do Portworx.

    11. Necessário apenas para Databases for etcd: insira as informações de sua instância de serviço do Databases for etcd.

      1. Recupere o terminal etcd e o nome do segredo do Kubernetes que você criou para seus Bancos de dados para a instância de serviço etcd.
      2. No campo Terminais de API do Etcd, insira o terminal de API de seus Bancos de dados para a instância de serviço etcd que você recuperou anteriormente. Certifique-se de inserir o terminal no formato etcd:<etcd_endpoint1>;etcd:<etcd_endpoint2>. Se você tiver mais de um terminal, inclua todos os terminais e separe-os com um ponto e vírgula (;).
      3. No campo Nome do segredo do Etcd, insira o nome do segredo do Kubernetes que você criou em seu cluster para armazenar os Bancos de dados para credenciais de serviço etcd.

    12. Na lista suspensa Nome do cluster do Kubernetes ou OpenShift, selecione o cluster no qual você deseja instalar o Portworx. Se seu cluster não estiver listado, assegure-se de selecionar a região do IBM Cloud correta. Se a região estiver correta, verifique se você tem as permissões corretas para visualizar e trabalhar com o seu cluster. Certifique-se de selecionar um cluster que atenda aos requisitos mínimos de hardware para o Portworx.

    13. Opcional: na lista suspensa Tipo de armazenamento de segredo do Portworx, escolha o tipo de armazenamento de segredo que deseja usar para armazenar a chave de criptografia de volume.

      • Segredo do Kubernetes: escolha essa opção se desejar armazenar sua própria chave customizada para criptografar seus volumes em um Segredo do Kubernetes em seu cluster. O segredo não deve estar presente antes de instalar o Portworx. É possível criar o segredo após instalar o Portworx. Para obter mais informações, consulte a Documentação do Portworx.
      • IBM Key Protect: escolha essa opção se desejar usar as chaves raiz no IBM Key Protect para criptografar seus volumes. Assegure-se de seguir as instruções para criar sua instância de serviço do IBM Key Protect e para armazenar as credenciais de como acessar sua instância de serviço em um segredo do Kubernetes no projeto portworx antes de instalar o Portworx.

    14. Opcional: para configurar um dispositivo de diário ou dispositivos KVDB, insira os detalhes do dispositivo no campo Opções avançadas.. Escolha dentre as opções a seguir para dispositivos de diário.

      • Insira j;auto para permitir que o Portworx crie automaticamente uma partição de 3 GB em um dos dispositivos Block Storage para usar para o diário.
      • Insira j;</device/path> para usar um dispositivo específico para o diário. Por exemplo, insira j;/dev/vde para usar o disco localizado em /dev/vde. Para localizar o caminho do dispositivo que deseja utilizar para o diário, efetue login em um nó do trabalhador e execute lsblk.
      • Insira kvdb_dev;<device path> para especificar o dispositivo onde deseja armazenar dados internos do KVDB. Por exemplo, kvdb_dev;/dev/vdd. Para localizar o caminho do dispositivo que deseja utilizar, efetue login em um nó do trabalhador e execute lsblk. Para usar um dispositivo específico para dados do KVDB, deve-se ter um dispositivo de armazenamento disponível de 3 GB ou em pelo menos três nós do trabalhador. Os dispositivos também devem estar no mesmo caminho em cada nó de trabalho. Por exemplo: /dev/vdd.

  2. Clique em Criar para iniciar a instalação do Portworx em seu cluster. Esse processo pode levar alguns minutos para ser concluído. A página de detalhes do serviço é aberta com instruções de como verificar sua instalação do Portworx, criar uma solicitação de volume persistente (PVC) e montar a PVC em um app.

  3. Na Lista de recursos da IBM Cloud, localize o serviço Portworx que você criou.

  4. Revise a coluna Status para ver se a instalação foi bem-sucedida ou falhou. O status pode levar alguns minutos para ser atualizado.

  5. Se o Status mudar para Provision failure, siga as instruções para iniciar a resolução de problemas do porquê sua instalação falhou.

  6. Se o Status mudar para Provisioned, verifique se sua instalação do Portworx foi concluída com sucesso e se todos os seus discos locais foram reconhecidos e incluídos na camada de armazenamento do Portworx.

    1. Liste os pods do Portworx no projeto kube-system. A instalação é bem-sucedida quando você vê um ou mais pods portworx, stork e stork-scheduler. O número de pods é igual ao número de nós do trabalhador que estão no cluster Portworx. Todos os pods devem estar em um estado Running.
        oc get pods -n kube-system | grep 'portworx\|stork'
    ```
    Saída de exemplo
    ```sh {: screen}
    portworx-594rw                          1/1       Running     0          20h
    portworx-rn6wk                          1/1       Running     0          20h
    portworx-rx9vf                          1/1       Running     0          20h
    stork-6b99cf5579-5q6x4                  1/1       Running     0          20h
    stork-6b99cf5579-slqlr                  1/1       Running     0          20h
    stork-6b99cf5579-vz9j4                  1/1       Running     0          20h
    stork-scheduler-7dd8799cc-bl75b         1/1       Running     0          20h
    stork-scheduler-7dd8799cc-j4rc9         1/1       Running     0          20h
    stork-scheduler-7dd8799cc-knjwt         1/1       Running     0          20h
    ```
2. Efetue login em um de seus pods `portworx` e liste o status de seu cluster Portworx.
```sh {: pre}
    oc exec <portworx_pod> -it -n kube-system -- /opt/pwx/bin/pxctl status
    ```
    Saída de exemplo
    ```sh {: screen}
    Status: PX is operational
    License: Trial (expires in 30 days)
    Node ID: 10.176.48.67
    IP: 10.176.48.67
    Local Storage Pool: 1 pool
    POOL    IO_PRIORITY    RAID_LEVEL    USABLE    USED    STATUS    ZONE    REGION
      0    LOW        raid0        20 GiB    3.0 GiB    Online    dal10    us-south
    Local Storage Devices: 1 device
    Device    Path                        Media Type        Size        Last-Scan
        0:1    /dev/mapper/3600a09803830445455244c4a38754c66    STORAGE_MEDIUM_MAGNETIC    20 GiB        17 Sep 18 20:36 UTC
            total                            -            20 GiB
    Cluster Summary
    Cluster ID: mycluster
        Cluster UUID: a0d287ba-be82-4aac-b81c-7e22ac49faf5
    Scheduler: kubernetes
    Nodes: 2 node(s) with storage (2 online), 1 node(s) without storage (1 online)
      IP        ID        StorageNode    Used    Capacity    Status    StorageStatus    Version        Kernel            OS
      10.184.58.11    10.184.58.11    Yes        3.0 GiB    20 GiB        Online    Up        1.5.0.0-bc1c580    4.4.0-133-generic    Ubuntu 20.04.5 LTS
      10.176.48.67    10.176.48.67    Yes        3.0 GiB    20 GiB        Online    Up (This node)    1.5.0.0-bc1c580    4.4.0-133-generic    Ubuntu 20.04.5 LTS
      10.176.48.83    10.176.48.83    No        0 B    0 B        Online    No Storage    1.5.0.0-bc1c580    4.4.0-133-generic    Ubuntu 20.04.5 LTS
    Global Storage Pool
      Total Used        :  6.0 GiB
      Total Capacity    :  40 GiB
    ```
3. Verifique se todos os nós do trabalhador que você queria incluir em sua camada de armazenamento do Portworx estão incluídos, revisando a coluna **StorageNode** na seção **Resumo do cluster** de sua saída da CLI. Os nós do trabalhador que estão na camada de armazenamento são exibidos com `Yes` na coluna **StorageNode**.

    Como o Portworx é executado como um DaemonSet no cluster, os nós do trabalhador existentes são inspecionados automaticamente para o Block Storage bruto e incluídos na camada de dados do Portworx quando o Portworx é implementado. Se você incluir nós do trabalhador no cluster e incluir o Block Storage bruto nesses trabalhadores, reinicie os pods do Portworx nos novos nós do trabalhador para que os volumes de armazenamento sejam detectados pelo DaemonSet.
    {: note}

4. Verifique se cada nó de armazenamento está listado com a quantidade correta de armazenamento de bloco bruto revisando a coluna **Capacidade** na seção **Resumo do Cluster** de sua saída da CLI.

5. Revise a classificação de E/S do Portworx que foi designada aos discos que fazem parte do cluster Portworx. Durante a configuração de seu cluster do Portworx, cada disco é inspecionado para determinar o perfil de desempenho do dispositivo. A classificação de perfil depende da rapidez da rede à qual o seu nó do trabalhador está conectado e o tipo de dispositivo de armazenamento que você tem. Discos de nós do trabalhador SDS são classificados como `high`. Se você conectar discos manualmente a um nó do trabalhador virtual, esses discos serão classificados como `low` devido à velocidade de rede mais lenta que vem com os nós do trabalhador virtual.
```sh {: pre}
    oc exec -it <portworx_pod> -n kube-system -- /opt/pwx/bin/pxctl cluster provision-status
    ```
    Saída de exemplo

    ```sh {: screen}
    NODE        NODE STATUS    POOL    POOL STATUS    IO_PRIORITY    SIZE    AVAILABLE    USED    PROVISIONED    RESERVEFACTOR    ZONE    REGION        RACK
    10.184.58.11    Up        0    Online        LOW        20 GiB    17 GiB        3.0 GiB    0 B        0        dal12    us-south    default
    10.176.48.67    Up        0    Online        LOW        20 GiB    17 GiB        3.0 GiB    0 B        0        dal10    us-south    default
    10.176.48.83    Up        0    Online        HIGH        3.5 TiB    3.5 TiB        10 GiB    0 B        0        dal10    us-south    default
    ```

Criando um volume do Portworx

Comece a criar volumes d Portworx, utilizando o provisionamento dinâmico d Kubernetes.

  1. Listar as classes de armazenamento disponíveis em seu cluster e verificar se é possível usar uma classe de armazenamento do Portworx existente que foi configurada durante a instalação do Portworx. As classes de armazenamento predefinidas são otimizadas para uso do banco de dados e para compartilhamento de dados entre os pods.

    oc get sc | grep portworx

    Para visualizar os detalhes de uma classe de armazenamento, execute oc describe storageclass <storageclass_name>.

  2. Se você não desejar usar uma classe de armazenamento existente, crie uma classe de armazenamento customizada. Para obter uma lista completa de opções suportadas que podem ser especificadas na classe de armazenamento, consulte Usando o fornecimento dinâmico.

    1. Crie um arquivo de configuração para sua classe de armazenamento.
        kind: StorageClass
    apiVersion: storage.k8s.io/v1
    metadata:
      name: <storageclass_name>
    provisioner: kubernetes.io/portworx-volume
    parameters:
      repl: "<replication_factor>"
      secure: "<true_or_false>"
      priority_io: "<io_priority>"
      shared: "<true_or_false>"
    ```
    `metadata.name`
    :   Insira um nome para a sua classe de armazenamento.

    `parameters.repl`
    :   Insira o número de réplicas para seus dados que você deseja armazenar em diferentes nós do trabalhador. Os números permitidos são `1`,`2`ou `3`. Por exemplo, se você inserir `3`, os dados serão replicados por meio de três nós diferentes do trabalhador no cluster Portworx. Para armazenar seus dados altamente disponíveis, use um cluster multizona e replique seus dados em três nós do trabalhador em zonas diferentes.
                    Deve-se ter nós do trabalhador suficientes para atender ao requisito de replicação. Por exemplo, se você tiver dois nós do trabalhador, mas especificar três réplicas, a criação do PVC com essa classe de armazenamento falhará.
        {: note}

    `parameters.secure`
    :   Especifique se você deseja criptografar os dados em seu volume com IBM Key Protect. Escolha entre as opções a seguir.
        - `true`: Insira `true` para ativar a criptografia para os volumes Portworx. Para criptografar volumes, deve-se ter uma instância de serviço do IBM Key Protect e um segredo do Kubernetes que retém a chave raiz do cliente. Para obter mais informações sobre como configurar a criptografia para volumes Portworx, consulte [Criptografando seus volumes Portworx](/docs/openshift?topic=openshift-storage_portworx_encryption).
        - `false`: quando você insere `false`, seus volumes do Portworx não são criptografados. Se você não especificar essa opção, os volumes Portworx não serão criptografados por padrão. É possível optar por ativar a criptografia de volume em seu PVC, mesmo que a criptografia tenha sido desativada em sua classe de armazenamento. A configuração que você faz no PVC tem precedência sobre as configurações na classe de armazenamento.

    `parameters.priority_io`
    :   Insira a prioridade de E/S do Portworx que você deseja solicitar para seus dados. As opções disponíveis são `high`, `medium` e `low`. Durante a configuração de seu cluster do Portworx, cada disco é inspecionado para determinar o perfil de desempenho do dispositivo. A classificação do perfil depende da largura da banda da rede do nó do trabalhador e do tipo de dispositivo de armazenamento. Discos de nós do trabalhador SDS são classificados como `high`. Se você conectar discos manualmente a um nó do trabalhador virtual, esses discos serão classificados como `low` devido à velocidade de rede mais lenta que vem com os nós do trabalhador virtual.
        :   Ao criar uma PVC com uma classe de armazenamento, o número de réplicas especificado em `parameters/repl` substituia prioridade de E/S. Por exemplo, ao especificar três réplicas que você deseja armazenar em discos de alta velocidade, mas se você tiver apenas um nó do trabalhador com um disco de alta velocidade em seu cluster, sua criação PVC ainda será bem-sucedida. Seus dados são replicados em discos de alta velocidade e de baixa velocidade.

    `parameters.shared`
    :   Defina se você deseja permitir que vários grupos acessem o mesmo volume. Escolha entre as opções a seguir:
        - True: se você configurar esta opção como `true`, poderá acessar o mesmo volume por meio de vários pods que estão distribuídos entre nós do trabalhador em diferentes zonas.
        - False: se você configurar esta opção como `false`, poderá acessar o volume por meio de vários pods apenas se os pods estiverem implementados no nó do trabalhador que conecta o disco físico que suporta o volume. Se o pod for implementado em um nó do trabalhador diferente, ele não poderá acessar o volume.

2. Crie a classe de armazenamento.
```sh {: pre}
    oc apply -f storageclass.yaml
    ```
3. Verifique se a classe de armazenamento foi criada.
```sh {: pre}
    oc get sc
    ```

  3. Crie uma solicitação de volume persistente (PVC).

    1. Crie um arquivo de configuração para seu PVC.
        kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: mypvc
    spec:
      accessModes:
        - <access_mode>
      resources:
        requests:
          storage: <size>
      storageClassName: portworx-shared-sc
    ```
    `metadata.name`
    :   Insira um nome para a PVC, como `mypvc`.

    `spec.accessModes`
    :   Insira o [Modo de acesso do Kubernetes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#access-modes){: external} que você deseja usar.

    `resources.requests.storage`
    :   Insira a quantia de armazenamento em gigabytes que você deseja designar do cluster Portworx. Por exemplo, para designar 2 gigabytes do seu cluster Portworx, insira `2Gi`. A quantia de armazenamento que você pode especificar é limitada pela quantia de armazenamento que está disponível em seu cluster Portworx. Se você especificou um fator de replicação na classe de armazenamento superior a um, a quantidade de armazenamento especificada na PVC será reservada em múltiplos nós do trabalhador.

    `spec.storageClassName`
    :   Insira o nome da classe de armazenamento que você escolheu ou criou anteriormente e que você deseja usar para fornecer seu PV. O arquivo YAML de exemplo usa a classe de armazenamento `portworx-shared-sc`.

2. Crie a PVC.
```sh {: pre}
    oc apply -f pvc.yaml
    ```
3. Verifique se o PVC foi criado e ligado a um volume persistente (PV). Esse processo pode demorar alguns minutos.
```sh {: pre}
    oc get pvc
    ```

Montando o volume em seu app

Para acessar o armazenamento do app, deve-se montar o PVC no app.

  1. Crie um arquivo de configuração para uma implementação que monta o PVC.

    Para obter dicas sobre como implementar um conjunto stateful com Portworx, consulte StatefulSets. A documentação Portworx também inclui exemplos de como implantar Cassandra, Kafka ElasticSearch com Kibana e WordPress com MySQL.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: <deployment_name>
  labels:
    app: <deployment_label>
spec:
  selector:
    matchLabels:
      app: <app_name>
  template:
    metadata:
      labels:
        app: <app_name>
    spec:
      schedulerName: stork
      containers:
      - image: <image_name>
        name: <container_name>
      securityContext:
          fsGroup: <group_ID>
        volumeMounts:
        - name: <volume_name>
          mountPath: /<file_path>
      volumes:
      - name: <volume_name>
        persistentVolumeClaim:
          claimName: <pvc_name>
    metadata.labels.app
    Um rótulo para a implementação.
    spec.selector.matchLabels.app e spec.template.metadata.labels.app
    Um rótulo para o seu app.
    template.metadata.labels.app
    Um rótulo para a implementação.
    spec.schedulerName
    Use o Stork como o planejador para o cluster Portworx. Com o Stork, você pode alojar pods junto com seus dados, o que garante uma migração contínua dos pods em caso de erros de armazenamento e facilita a criação e a restauração de instantâneos de volumes d Portworx.
    spec.containers.image
    O nome da imagem que você deseja usar. Para listar as imagens disponíveis em sua conta do IBM Cloud Container Registry, execute ibmcloud cr image-list.
    spec.containers.name
    O nome do contêiner que você deseja implementar em seu cluster.
    spec.containers.securityContext.fsGroup
    Opcional: para acessar o armazenamento com um usuário não raiz, especifique o contexto de segurança para o pod e defina o conjunto de usuários aos quais você deseja conceder acesso na seção fsGroup no YAML de implementação. Para obter mais informações, consulte Acessando volumes Portworx com um usuário não raiz.
    spec.containers.volumeMounts.mountPath
    O caminho absoluto do diretório no qual o volume está montado dentro do contêiner. Para compartilhar um volume entre diferentes apps, é possível especificar subcaminhos de volume para cada um dos apps.
    spec.containers.volumeMounts.name
    O nome do volume a ser montado no pod.
    volumes.name
    O nome do volume a ser montado no pod. Geralmente, esse nome é o mesmo que volumeMounts/name.
    volumes.persistentVolumeClaim.claimName
    O nome do PVC que liga o PV que você deseja usar.

  2. Crie sua implementação.

    oc apply -f deployment.yaml

  3. Verifique se o PV foi montado com êxito em seu app.

    oc describe deployment <deployment_name>

    O ponto de montagem está no campo Montagens de volume e o volume está no campo Volumes.

    Volume Mounts:
        /var/run/secrets/kubernetes.io/serviceaccount from default-token-tqp61 (ro)
        /volumemount from myvol (rw)
...
Volumes:
    myvol:
    Type:    PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:    mypvc
    ReadOnly:    false

  4. Verifique se é possível gravar dados em seu cluster do Portworx.

    1. Efetue login no pod que monta seu PV.
        oc exec <pod_name> -it bash
    ```
2. Navegue para o caminho de montagem do volume que você definiu em sua implementação de app.
3. Crie um arquivo de texto.
```sh {: pre}
    echo "This is a test" > test.txt
    ```
4. Leia o arquivo que você criou.
```sh {: pre}
    cat test.txt
    ```