Configurando um registro de imagem

Escolhendo uma solução de registro de imagem

Suas imagens de contêiner devem ser armazenadas em um registro de contêiner que o cluster possa acessar para implantar aplicativos no cluster. É possível optar por usar o registro integrado de seu cluster Red Hat OpenShift, um registro privado com acesso restrito para selecionar usuários, ou um registro público. Revise a tabela a seguir para escolher a melhor opção para seu caso de uso.

Red Hat OpenShift Container Registry (OCR) interno

Seu cluster é configurado com o Red Hat OpenShift Container Registry interno para que o Red Hat OpenShift possa construir, implementar e gerenciar automaticamente o seu ciclo de vida de aplicativo de dentro do cluster. As imagens são armazenadas em um dispositivo de armazenamento de arquivo clássico do IBM Cloud de apoio que é provisionado no horário de criação do cluster. Se você precisar de mais armazenamento, será possível redimensionar o dispositivo. Casos de uso:

• Fluxo de imagem nativo do Red Hat OpenShift, construção e processo de implementação de app em uma base por cluster.
• As imagens podem ser compartilhadas em todos os projetos no cluster, com acesso que é controlado por meio de funções RBAC.
• Integrando o registro interno a outros produtos do Red Hat como o CloudForms para recursos ampliados, como varredura de vulnerabilidade.
• Opção para expor o registro interno com uma rota para que os usuários possam extrair imagens do registro sobre a rede pública.
• Opção para configurar o registro interno para extrair imagens de ou enviar imagens por push para um registro privado, como o IBM Cloud Container Registry.

Para obter mais informações, consulte Usando o registro interno.

Registro privado

Registros privados são uma boa opção para proteger suas imagens de usuários não autorizados. Os registros privados devem ser configurados pelo administrador de cluster para assegurar que o acesso, as cotas de armazenamento, a confiança de imagem e outros recursos funcionem conforme desejado. Por padrão, seus clusters do Red Hat OpenShift são integrados com o IBM Cloud Container Registry privado por meio de segredos de extração de imagem no projeto default. O IBM Cloud Container Registry é um registro privado altamente disponível e com diversos locatários para armazenar suas próprias imagens. Também é possível extrair imagens fornecidas pela IBM por meio do registro icr.io global e do software licenciado por meio do registro autorizado. Com o IBM Cloud Container Registry, é possível gerenciar imagens para vários clusters com integração com o IBM Cloud IAM e o faturamento. Vantagens de usar o IBM Cloud Container Registry com o registro interno:

• Armazenamento em cache de imagem local para construções mais rápidas por meio do registro interno.
• As implementações em outros projetos podem ver o fluxo de imagem, para que não seja preciso copiar segredos de extração para cada projeto.
• Compartilhar imagens entre diversos clusters sem precisar enviar por push para diversos registros.
• Varrer automaticamente a vulnerabilidade de imagens.
• Controlar o acesso por meio de políticas do IBM Cloud IAM e de registros regionais separados.
• Reter imagens sem requerer espaço de armazenamento em seu cluster ou em um dispositivo de armazenamento anexado. Também é possível configurar políticas para gerenciar a quantidade de imagens para evitar que ocupem muito espaço.
• Infraestrutura de VPC: Uso do endpoint de serviço de registro privado para que os clusters que usam apenas um endpoint de serviço de nuvem privada ainda possam acessar o registro.
• Configurar cotas de tráfego de armazenamento e pull de imagem para melhor controlar o armazenamento, o uso e o faturamento de imagens.
• Fazer pull de conteúdo IBM licenciado por meio do registro autorizado.

Para começar, consulte os tópicos a seguir:

• Introdução ao IBM Cloud Container Registry.
• Importando imagens do IBM Cloud Container Registry para o fluxo de imagem de registro interno.
• Usando o IBM Cloud Container Registry.

Registro público

Registros públicos, como o Docker Hub, são uma forma de compartilhar imagens entre equipes, empresas, clusters ou provedores em nuvem. Alguns registros públicos também podem oferecer um componente de registro privado. Casos de uso:

• Enviando por push e fazendo pull de imagens na rede pública.
• Teste rápido de um contêiner entre provedores em nuvem.
• Não são necessários recursos de nível corporativo, como varredura de vulnerabilidade ou gerenciamento de acesso.

Para obter mais informações, consulte a documentação do registro público, como o Quay ou o Docker Hub.

Armazenando imagens nos registros internos

Por padrão, os clusters do Red Hat OpenShift têm um registro interno. As imagens no registro interno passam por backup, mas variam de acordo com o provedor de infraestrutura de seu Red Hat OpenShift on IBM Cloud cluster.

Classic clusters

Seu cluster Red Hat OpenShift é configurado por padrão com um registro interno que usa File Storage for Classic como armazenamento de apoio. Quando você exclui o cluster, o registro interno e suas imagens também são excluídos. Para persistir suas imagens, considere usar um registro privado, como o IBM Cloud Container Registry, fazer backup delas em um armazenamento persistente, como o Object Storage, ou criar um cluster de registro de contêiner do Red Hat OpenShift (OCR) independente e separado. Para obter mais informações, consulte o Red Hat OpenShift docs.

Clusters do VPC

O registro interno do seu cluster Red Hat OpenShift faz o backup das imagens em um bucket criado automaticamente em uma instância IBM Cloud Object Storage na sua conta. Todos os dados armazenados no bucket de armazenamento de objetos permanecem, mesmo quando você exclui o cluster.

Clusters clássicos, VPC ou Satellite

Opcionalmente, você pode optar por configurar o registro interno para armazenar dados no site emptyDir do nó de trabalho em que o pod de registro interno é executado. Lembre-se de que esses dados não são persistentes e se o pod ou o nó do trabalhador for reiniciado, os dados armazenados serão excluídos e irrecuperáveis. Será possível armazenar as imagens localmente no emptyDir para aumentar o desempenho se você construir contêineres por meio de imagens grandes regularmente.

oc describe pvc -n openshift-image-registry image-registry-storage

Removendo o registro de imagem interno

Nuvem privada virtual

As implantações do operador de registro de imagens estão presentes apenas em clusters gerenciados pelo Red Hat OpenShift on IBM Cloud Toolkit. HyperShift Os clusters gerenciados executam o operador de registro de imagens no plano de controle.

Se não desejar usar o registro de imagem interno, será possível concluir as etapas a seguir para removê-lo.

1. Salve uma cópia de suas configurações de registro interno

   oc get configs.imageregistry.operator.openshift.io cluster -o yaml > configs.yaml
   

2. Execute o comando de correção a seguir para mudar o estado de gerenciamento do registro de imagem para Removed

   kubectl patch configs.imageregistry.operator.openshift.io cluster -p '{"spec":{"managementState":"Removed"}}' --type='merge'
   

3. Depois de mudar o estado de gerenciamento, o serviço de registro de imagem e a implementação são removidos do namespace do openshift-image-registry em seu cluster. É possível executar os comandos a seguir para verificar se eles foram removidos Observe que apenas a implementação e o serviço de registro de imagens são removidos A implementação e o serviço do operador de registro de imagem permanecem

   oc get deployment -n openshift-image-registry
   

   oc get svc -n openshift-image-registry
   

Configurando uma rota externa segura para o registro interno

Por padrão, o seu cluster Red Hat OpenShift possui um registro interno que está disponível por meio de um serviço com um endereço IP interno. Se você deseja tornar o registro interno disponível na rede pública, é possível configurar uma rota de nova criptografia segura. Por exemplo, você pode configurar o registro interno de seu cluster para agir como um registro público para implementações em outros projetos ou clusters.

Antes de Iniciar:

• Confirme se você tem a função de acesso de serviço Gerenciador do IBM Cloud IAM para o cluster.
• Certifique-se de que seu cluster tenha conectividade de rede pública para expor o registro interno com uma rota pública.
• Instale o Docker em sua máquina local.
• Acesse o seu Red Hat OpenShift cluster.

Para usar o registro interno, configure uma rota pública para acessar o registro. Em seguida, crie um segredo de extração de imagem que inclua as credenciais para acessar o registro de modo que as implementações em outros projetos possam extrair imagens desse registro.

1. No projeto openshift-image-registry, certifique-se de que o serviço image-registry exista para o registro interno.

   oc get svc -n openshift-image-registry
   

   Exemplo de saída

   NAME                      TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                      AGE
   image-registry            ClusterIP      172.21.xxx.xxx    <none>          5000/TCP                     36d
   image-registry-operator   ClusterIP      None             <none>          60000/TCP                     36d
   

2. Crie uma rota protegida para o serviço image-registry que use a finalização do TLS reencrypt. Com a nova criptografia, o roteador finaliza a conexão TLS com um certificado e, em seguida, criptografa novamente a conexão com o registro interno com um certificado diferente. Com essa abordagem, o caminho completo da conexão entre o usuário e o registro interno é criptografado. Para fornecer seu próprio nome de domínio personalizado, inclua a opção --hostname.

   oc create route reencrypt --service=image-registry -n openshift-image-registry
   

3. Recupere o nome do host (HOST/PORTA) e a PORTA que foram designados à rota image-registry.

   oc get route image-registry -n openshift-image-registry
   

   Exemplo de saída

   NAME              HOST/PORT                                                                                                  PATH      SERVICES          PORT       TERMINATION   WILDCARD
   image-registry   image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud             image-registry   5000-tcp   reencrypt     None
   

4. Edite a rota para definir a estratégia de balanceamento de carga como source, de modo que o mesmo endereço IP do cliente chegue ao mesmo servidor, como em uma configuração de rota de passagem. É possível configurar a estratégia incluindo uma anotação na seção metadata.annotations: haproxy.router.openshift.io/balance: source. É possível editar o arquivo de configuração por meio do Console do aplicativo do Red Hat OpenShift ou em sua linha de comandos executando o comando a seguir.

   oc edit route image-registry -n openshift-image-registry
   

   Inclua a anotação.

   apiVersion: route.openshift.io/v1
   kind: Route
   metadata:
   annotations:
       haproxy.router.openshift.io/balance: source
   ...
   

5. Se as políticas de rede corporativa impedirem o acesso de seu sistema local a terminais públicos por meio de proxies ou firewalls, permita o acesso ao subdomínio de rota que você criará para o registro interno nas etapas a seguir.

6. etue login no registro interno usando a rota como o nome do host.

   docker login -u $(oc whoami) -p $(oc whoami -t) image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud
   

7. Agora que você efetuou login, tente enviar por push um app hello-world de amostra para o registro interno.

   1. Puxe a imagem hello-world do DockerHub ou construa uma imagem em sua máquina local.

      docker pull hello-world
      

   2. Identifique a imagem local com o nome do host de seu registro interno, o projeto para o qual você deseja implementar a imagem, o nome da imagem e a tag.

      docker tag hello-world:latest image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud/<project>/<image_name>:<tag>
      

   3. Envie por push a imagem para o registro interno de seu cluster.

      docker push image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud/<project>/<image_name>:<tag>
      

   4. Verifique se a imagem é incluída no fluxo de imagem do Red Hat OpenShift.

      oc get imagestream
      

      Exemplo de saída

      NAME          DOCKER REPO                                                            TAGS      UPDATED
      hello-world   image-registry-openshift-image-registry.svc:5000/default/hello-world   latest    7 hours ago
      

8. Para ativar implementações em seu projeto para extrair imagens do registro interno, crie um segredo de extração de imagem em seu projeto que retenha as credenciais para acessar seu registro interno. Em seguida, inclua o segredo de extração de imagem na conta do serviço padrão para cada projeto.

   1. Liste os segredos de extração de imagem que a conta do serviço padrão usa e anote o segredo que iniciar com default-dockercfg.

      oc describe sa default
      

      Exemplo de saída

      ...
      Image pull secrets:
      all-icr-io
      default-dockercfg-mpcn4
      ...
      

   2. Obtenha as informações secretas codificadas do campo data do arquivo de configuração.

      oc get secret <default-dockercfg-name> -o yaml
      

      Exemplo de saída

      apiVersion: v1
      data:
        .dockercfg: ey...=
      

   3. Decodifique o valor do campo data.

      echo "<ey...=>" | base64 -D
      

      Exemplo de saída

      {"172.21.xxx.xxx:5000":{"username":"serviceaccount","password":"eyJ...
      

   4. Crie um novo segredo de extração de imagem para o registro interno.

      • secret_name: dê um nome ao segredo de extração de imagem, como internal-registry.
      • --namespace: insira o projeto no qual criar o segredo de extração de imagem, como default.
      • --docker-server: Em vez do endereço IP de serviço interno (172.21.xxx.xxx:5000), digite o nome do host da rota image-registry com a porta (image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud:5000).
      • --docker-username: copie o "username" do segredo de extração de imagem anterior, como serviceaccount.
      • --docker-password: copie a "password" do segredo de extração de imagem anterior.
      • --docker-email: se você tiver um, insira seu endereço de e-mail do Docker. Caso contrário, insira um endereço de e-mail fictício, como a@b.c. Esse e-mail é necessário para criar um segredo do Kubernetes, mas não é usado após a criação.

      oc create secret docker-registry internal-registry --namespace default --docker-server image-registry-openshift-image-registry.<cluster_name>-<ID_string>.<region>.containers.appdomain.cloud:5000 --docker-username serviceaccount --docker-password <eyJ...> --docker-email a@b.c
      

   5. Inclua o segredo de extração da imagem na conta do serviço padrão de seu projeto.

      oc patch -n <namespace_name> serviceaccount/default --type='json' -p='[{"op":"add","path":"/imagePullSecrets/-","value":{"name":"<image_pull_secret_name>"}}]'
      

   6. Repita estas etapas para cada projeto que você deseja extrair imagens do registro interno.

Agora que você configurou o registro interno com uma rota acessível, é possível efetuar login, enviar por push e extrair imagens para o registro. Para obter mais informações, consulte o Red Hat OpenShift documentação.

Importando imagens do IBM Cloud Container Registry para o fluxo de imagem de registro interno

Por padrão, o seu cluster do Red Hat OpenShift on IBM Cloud é configurado para extrair imagens dos domínios icr.io remotos e privados do IBM Cloud Container Registry no projeto default. Você pode importar uma imagem do site IBM Cloud Container Registry para o registro interno do cluster Red Hat OpenShift marcando a imagem como um fluxo de imagem. Com essa configuração, é possível implementar apps por meio da imagem usando o cache local do registro interno, o que pode fazer com que suas implementações de app sejam construídas mais rapidamente. Além disso, as implementações em outros projetos podem se referir ao fluxo de imagens, sem que seja necessário criar credenciais de segredo de extração de imagens para o IBM Cloud Container Registry em cada projeto.

Se você atualizar sua imagem no IBM Cloud Container Registry, ela não será extraída automaticamente para o registro interno de seu cluster Red Hat OpenShift. Em vez disso, configure a importação periódica ou repita estas etapas para marcar a imagem. Dependendo da política de extração de imagem usada em sua implementação, também pode ser necessário reiniciar sua implementação.

Deseja aprender mais sobre como as construções, os fluxos de imagem e o registro interno funcionam juntos? Leia a Red Hat OpenShift documentação ou confira este blog sobre gerenciamento de imagens de contêineres.

1. Acesse o seu Red Hat OpenShift cluster.

2. Alterne para o projeto default para extrair sua imagem para o fluxo de imagem. O projeto default já está configurado com credenciais para acessar os registros icr.io.

   oc project default
   

3. Liste as imagens disponíveis em seu IBM Cloud Container Registry. Observe o Repositório e a Tag da imagem que você deseja extrair para o registro interno de seu cluster Red Hat OpenShift.

   ibmcloud cr images
   

4. Identifique a imagem para extraí-la do seu namespace do IBM Cloud Container Registry para o registro interno como um fluxo de imagem. Para obter mais informações, consulte a documentação Red Hat OpenShift ou execute oc tag --help.

   oc tag <region>.icr.io/<namespace>/<image>:<tag> default/<image>:<tag> --reference-policy=local [--scheduled]
   

   • <region>.icr.io/<namespace>/<image>:<tag>: Use as informações de Repositório e Tag que você recuperou anteriormente para completar a região IBM Cloud Container Registry, o namespace, a imagem e o nome da tag da imagem que você deseja extrair.
   • default/<image>:<tag>: Digite as informações para o fluxo de imagem interno que você criar por meio da imagem identificada do IBM Cloud Container Registry. Você cria este fluxo de imagem no projeto default, que também é o projeto em que o fluxo de imagem é criado, caso você não especifique um projeto. Os valores para <image>:<tag> geralmente correspondem aos valores que você recuperou anteriormente.
   • --reference-policy=local: configure este valor como local para que uma cópia da imagem do IBM Cloud Container Registry seja importada para o cache local do registro interno e disponibilizada para os projetos do cluster como um fluxo de imagem. Se você não incluir este valor, o fluxo de imagem voltará a referenciar o IBM Cloud Container Registry quando ele for usado em suas implementações e, portanto, requer credenciais no projeto.
   • --scheduled: Defina essa opção opcional para configurar a importação periódica da imagem do site IBM Cloud Container Registry para o registro interno. A frequência padrão é de 15 minutos. Para obter mais informações, consulte o Red Hat OpenShift documentação.

5. Verifique se o seu fluxo de imagem é criado.

   oc get imagestreams
   

6. Verifique se o fluxo de imagem extraiu com sucesso a imagem do IBM Cloud Container Registry. Na saída, verifique se a imagem identificada mais recentemente corresponde à sua imagem * <region>.icr.io/<namespace>/<image>@<digest>.

   oc describe is/<imagestream>
   

   Exemplo de saída

   NAME:            <imagestream>
   Namespace:        default
   Created:        2 days ago
   Labels:            <none>
   Annotations:        openshift.io/image.dockerRepositoryCheck=2020-03-31T09:41:36Z
   Image Repository:    image-registry.openshift-image-registry.svc:5000/default/ant1
   Image Lookup:        local=false
   Unique Images:        1
   Tags:                1
   
   latest
       tagged from <region>.icr.io/<namespace>/<image>:<tag>
   
       * <region>.icr.io/<namespace>/<image>@<digest>
           2 days ago
   

Agora, seus desenvolvedores podem usar o fluxo de imagem em uma implementação de app. A imagem é construída com sucesso por meio da imagem extraída localmente no registro interno. Não é necessário configurar um segredo de extração de imagem no projeto para o IBM Cloud Container Registry, porque o fluxo de imagem é local para o cluster.

Configurando construções no registro interno para enviar por push imagens para o IBM Cloud Container Registry

Ao criar uma compilação no seu Red Hat OpenShift on IBM Cloud cluster, você pode configurar o registro interno para enviar a imagem para o seu repositório externo em IBM Cloud Container Registry. Por padrão, o segredo de extração de imagem no projeto default do seu cluster somente tem acesso de leitura para extrair imagens do IBM Cloud Container Registry. Para enviar por push imagens, deve-se incluir um segredo com acesso de gravação.

1. Acesse o seu Red Hat OpenShift cluster.

2. Alterne para o projeto default.

   oc project default
   

3. Siga as etapas para configurar uma chave de API do IBM Cloud IAM com as funções de acesso de serviço Reader e Writer para extrair e enviar por push as imagens para os seus registros icr.io.

   Tenha em mente que qualquer usuário com acesso ao projeto pode usar esse segredo para enviar por push as imagens para o seu registro privado. É possível que você queira configurar ferramentas de criação de log e de monitoramento para que seja possível observar quem faz quais ações em seu cluster.

4. Repita a etapa anterior para cada região do icr.io para a qual você deseja enviar por push as imagens.

5. Inclua o segredo na conta do serviço de construção e refira-se aos segredos no arquivo de configuração de construção. Para obter mais informações, consulte o Red Hat OpenShift documentação.

   1. Inclua o segredo na conta do serviço de construção, vinculando o segredo que você acabou de criar à função builder usada por todas as construções no cluster.

      oc secrets link builder <secret_name>
      

   2. Liste as configurações de construção e anote as que você deseja dar acesso de extração e envio por push ao IBM Cloud Container Registry.

      oc get bc
      

   3. Configure o segredo de extração de imagem para a configuração de construção para usar o segredo que você acabou de criar com o acesso de serviço Writer para o IBM Cloud Container Registry.

      oc set build-secret --push bc/<build_config_name> <secret_name>
      

   4. Configure o segredo de extração de imagem para a configuração de construção para extrair do registro do qual você deseja extrair a imagem de construção inicial. Por exemplo, será possível usar o segredo que você acabou de criar com o acesso de serviço Reader ao IBM Cloud Container Registry se a imagem de origem estiver em um repositório do IBM Cloud Container Registry.

      oc set build-secret --pull bc/<build_config_name> <secret_name>
      

6. Depois de atualizar a conta do serviço de construção e o arquivo de configuração de construção para enviar por push para o IBM Cloud Container Registry, reinicie sua construção.

   oc start-build <build_name>
   

7. Obtenha o nome do seu pod de construção, como <build>-2-build.

   oc get pods
   

8. Verifique os logs da construção e anote o local no qual imagem foi enviada por push.

   oc logs <build_pod>
   

   Exemplo de log de envio por push de imagem bem-sucedido.

   ...
   Successfully pushed <region>.icr.io/<namespace>/<build_name>@sha256:<hash>
   Push successful
   

9. Verifique suas imagens em seu registro privado para confirmar se a imagem foi criada.

   ibmcloud cr image list
   

   Exemplo de saída

   Repository                                Tag       Digest     Namespace     Created         Size     Security status   
   <region>.icr.io/<namespace>/<build_name>  latest    <digest>   <namespace>   2 minutes ago   182 MB   33 Issues  
   

Sua construção do Red Hat OpenShift agora pode extrair imagens e enviar imagens por push para o IBM Cloud Container Registry.

Usando o IBM Cloud Container Registry

Por padrão, o seu cluster do Red Hat OpenShift on IBM Cloud é configurado para extrair imagens dos domínios icr.io remotos e privados do IBM Cloud Container Registry no projeto default. Se você desejar usar imagens que estão armazenadas no IBM Cloud Container Registry para outros projetos, será possível extrair a imagem para o registro interno em um fluxo de imagem ou criar segredos de extração de imagem para cada registro global e regional em cada projeto.

Para importar imagens para o registro interno: consulte Importando imagens do IBM Cloud Container Registry para o fluxo de imagem de registro interno.

Para extrair imagens diretamente do IBM Cloud Container Registry externo: consulte os tópicos a seguir.

• Entendendo como autorizar seu cluster para extrair imagens por meio de um registro.
• Copiando o segredo all-icr-io do projeto default para o projeto do qual você deseja extrair imagens.
• Criando seu próprio segredo de extração de imagem.
• Incluindo o segredo de extração de imagem na sua configuração de implementação ou na conta do serviço do projeto.

Entendendo como autorizar seu cluster a extrair imagens de um registro privado

Para fazer pull de imagens de um registro, seu cluster do Red Hat OpenShift on IBM Cloud usa um tipo especial de segredo do Kubernetes, um imagePullSecret. Esse segredo de extração de imagem armazena as credenciais para acessar um registro de contêiner.

O registro do contêiner pode ser:

• Um namespace privado em seu próprio IBM Cloud Container Registry.
• Um namespace privado em IBM Cloud Container Registry que pertence a uma conta do IBM Cloud diferente.
• Qualquer outro registro privado como Docker.

No entanto, por padrão, seu cluster é configurado para extrair imagens apenas dos namespaces de sua conta no IBM Cloud Container Registry e implementar contêineres dessas imagens para o projeto default do Red Hat OpenShift em seu cluster. Se for necessário extrair imagens em outros projetos do cluster ou de outros registros de contêiner, seus próprios segredos de extração de imagem deverão ser configurados.

Atualizando os clusters existentes para usar o segredo de extração de imagem da chave de API

Novos clusters do Red Hat OpenShift on IBM Cloud armazenam uma chave de API em segredos de extração de imagem para autorizar o acesso ao IBM Cloud Container Registry. Com esses segredos de extração de imagem, é possível implementar contêineres de imagens que são armazenados nos domínios de registro icr.io. Será possível incluir os segredos de extração de imagem em seu cluster se ele não tiver sido criado com os segredos.

Antes de Iniciar

1. Acesse o seu Red Hat OpenShift cluster.

2. Verfique se você tem as seguintes permissões: IBM Cloudfunção da plataforma de acesso Operador ou Administrador do IAM para Red Hat OpenShift on IBM Cloud. O proprietário da conta pode conceder-lhe a função executando o comando a seguir.

   ibmcloud iam user-policy-create EMAIL --service-name containers-kubernetes --roles "Administrator,Operator"
   

3. Função de acesso à plataforma Administrador do IBM Cloud IAM para o IBM Cloud Container Registry, em todas as regiões e grupos de recursos. A política não pode ter o escopo definido para uma determinada região ou grupo de recursos. O proprietário da conta pode conceder-lhe a função executando o comando a seguir.

   Verifique se o segredo foi criado com sucesso

   ibmcloud iam user-policy-create <your_user_email> --service-name container-registry --roles Administrator
   

4. Se a sua conta restringir a criação de ID de serviço, inclua a função Criador de ID de serviço em Identity and Access Management no console (iam-identity na API ou CLI).

5. Se a sua conta restringir a criação de chave de API, inclua a função Criador de chave de API do usuário em Identity and Access Management no console (iam-identity na API ou CLI).

Uso de um segredo de extração de imagem para acessar imagens em registros privados externos

Configure seu próprio segredo de extração de imagem em seu cluster para implementar contêineres em projetos do Red Hat OpenShift diferentes de default, use imagens que são armazenadas em outras da IBM Cloud ou use imagens que são armazenadas em registros privados externos. Além disso, você pode criar seu próprio segredo de extração de imagem para aplicar políticas de acesso do IAM que restringem permissões a namespaces ou ações de imagem de registro específicos (como push ou pull).

Depois da criação do segredo de extração de imagem, seus contêineres devem usá-lo para obter autorização para o pull de uma imagem do registro. É possível incluir o segredo de extração da imagem na conta do serviço do projeto ou referir-se ao segredo em cada implementação. Para obter instruções, consulte Usando o segredo de extração de imagem para implementar contêineres.

Os segredos de extração de imagem são válidos apenas para os projetos do Red Hat OpenShift para os quais eles foram criados. Repita essas etapas para cada namespace no qual você desejar implementar contêineres.

Antes de Iniciar:

1. Configure um namespace no IBM Cloud Container Registry e envie por push as imagens para esse namespace.
2. Criar um cluster.
3. Acesse o seu Red Hat OpenShift cluster.

Para usar seu próprio segredo de extração de imagem, escolha entre as opções a seguir:

• Copie o segredo de extração de imagem do projeto do Red Hat OpenShift padrão para outros projetos em seu cluster.
• Crie novas credenciais de chave de API do IAM e as armazene em um segredo de pull de imagem para acessar imagens em outras contas do IBM Cloud ou para aplicar políticas IAM que restrinjam o acesso a determinados domínios de registro ou namespaces.
• Crie um segredo de extração de imagem para acessar imagens em registros privados externos.

Se você já criou um segredo de extração de imagem em seu projeto que deseja usar em sua implementação, consulte Implementando contêineres usando o imagePullSecret criado.

Usando o segredo de extração de imagem para implementar contêineres

É possível definir um segredo de extração de imagem na implementação do pod ou armazenar o segredo de extração de imagem na conta de serviço do Kubernetes para que ele fique disponível para todas as implementações que não especificarem uma conta de serviço do Kubernetes no projeto.

Para planejar como os segredos de extração de imagem são usados no cluster, escolha entre as opções a seguir.

• Fazer referência ao segredo de extração de imagem na implementação do pod: use esta opção se não quiser conceder acesso ao registro para todos os pods no projeto por padrão. Os desenvolvedores podem incluir o segredo de extração de imagem em cada implementação de pod que deve acessar seu registro.
• Armazenando o segredo de extração de imagem na conta do serviço do Kubernetes: use essa opção para conceder acesso às imagens em seu registro para todas as implementações nos projetos do Red Hat OpenShift selecionados. Para armazenar um segredo de extração de imagem na conta de serviço do Kubernetes, use as etapas a seguir.

Configurando um cluster para extrair o software autorizado

É possível configurar seu cluster do Red Hat OpenShift on IBM Cloud para puxar o software autorizado, que é uma coleção de imagens de contêiner protegidas que são empacotadas em gráficos do Helm que você está licenciado pela IBM a usar. O software autorizado é armazenado em um domínio especial do cp.icr.io do IBM Cloud Container Registry. Para acessar esse domínio, deve-se criar um segredo de extração de imagem com uma chave de autorização para o cluster e incluir esse segredo de extração de imagem na conta do serviço do Kubernetes de cada projeto no qual se deseja implementar esse software autorizado.

Antes de começar: acesse o seu cluster do Red Hat OpenShift.

1. Obtenha a chave de autorização para sua biblioteca de software autorizada.

   1. Efetue login no MyIBM.com e role até a seção Biblioteca de software de contêiner. Clique em Visualizar biblioteca.
   2. Na página Acessar seu software de contêiner > Chaves de autorização, clique em Copiar chave. Essa chave autoriza o acesso a todos os softwares autorizados na sua biblioteca de softwares de contêiner.

2. No projeto que deseja implementar seus contêineres autorizados, crie um segredo de extração de imagem para que seja possível acessar o registro autorizado cp.icr.io. Use a chave de autorização que você recuperou anteriormente como o valor --docker-password. Para obter mais informações, consulte Acessando imagens que são armazenadas em outros registros privados.

   oc create secret docker-registry entitled-cp-icr-io --docker-server=cp.icr.io --docker-username=cp --docker-password=<entitlement_key> --docker-email=<docker_email> -n <project>
   

3. Inclua o segredo de extração de imagem na conta do serviço do namespace para que qualquer contêiner no projeto possa usar a chave de autorização para extrair as imagens autorizadas. Para obter mais informações, consulte Usando o segredo de extração de imagem para implementar contêineres.

   oc patch -n <project> serviceaccount/default --type='json' -p='[{"op":"add","path":"/imagePullSecrets/-","value":{"name":"entitled-cp-icr-io"}}]'
   

4. Crie um pod no projeto que construa um contêiner por meio de uma imagem no registro autorizado.

   oc run <pod_name> --image=cp.icr.io/<image_name> -n <project> --generator=run-pod/v1
   

5. Verifique se seu contêiner foi capaz de construir com êxito por meio da imagem autorizada, verificando se o pod está em um status Executando.

   oc get pod <pod_name> -n <project>
   

Imaginando o que fazer em seguida? É possível configurar o repositório de gráfico do Helm autorizado, em que os gráficos do Helm que incorporam o software autorizado são armazenados. Se você já tiver o Helm instalado em seu cluster, execute helm repo add entitled https://raw.githubusercontent.com/IBM/charts/master/repo/entitled.

Incluindo um registro privado no segredo de extração global

Nós de trabalho RHEL

Em clusters que usam apenas nós de trabalho RHEL, é possível configurar um segredo de extração de imagem global que cada nó de trabalho no cluster pode usar para extrair imagens de um registro privado.

Por padrão, seu cluster Red Hat OpenShift on IBM Cloud tem um segredo de extração de imagem global para os registros a seguir, de modo que os componentes padrão do Red Hat OpenShift podem ser implementados.

• cloud.openshift.com
• quay.io
• registry.connect.redhat.com
• registry.redhat.io

Não substitua o segredo de extração global por um segredo de extração que não tenha credenciais para os registros padrão do Red Hat. Se você fizer, os componentes padrão Red Hat OpenShift que estão instalados em seu cluster, como o OperatorHub, podem falhar porque eles não conseguem fazer pull de imagens desses registros.

Antes de Iniciar:

• Faça o download do pacote de linha de comando do processador jq JSON. O jq é usado para combinar o valor JSON do segredo de extração global padrão com o segredo de extração de registro privado que você deseja incluir.
• Acesse o seu Red Hat OpenShift cluster.

Para incluir registros privados, edite o pull-secret global no projeto openshift-config.

1. Crie um valor de segredo que mantenha as credenciais para acessar o seu registro privado e armazene o valor de segredo decodificado em um arquivo JSON. Ao criar o valor de segredo, as credenciais são automaticamente codificadas para base64. Ao usar a opção --dry-run, somente o valor de segredo é criado e nenhum objeto de segredo é criado em seu cluster. O valor de segredo decodificado é, então, armazenado em um arquivo JSON para uso posterior em seu segredo de extração global.

   oc create secret docker-registry <secret_name> --docker-server=<registry_URL> --docker-username=<docker_username> --docker-password=<docker_password> --docker-email=<docker_email> --dry-run=true --output="jsonpath={.data.\.dockerconfigjson}" | base64 --decode > myregistryconfigjson
   

   --namespace <project>

   Obrigatório. O projeto do Red Hat OpenShift de seu cluster no qual você deseja usar o segredo e implementar os contêineres. Para listar os projetos disponíveis em seu cluster, execute oc get ns.

   <secret_name>

   Obrigatório. O nome que você deseja usar para seu segredo de extração de imagem.

   --docker-server <registry_URL>

   Obrigatório. A URL para o registro no qual as imagens privadas são armazenadas.

   --docker-username <docker_username>

   Obrigatório. O nome de usuário para efetuar login em seu cadastro privado.

   --docker-password <token_value>

   Obrigatório. A senha para fazer login em seu registro privado, como um valor do token.

   --docker-email <docker-email>

   Obrigatório. Se você tiver um, insira seu endereço de e-mail do Docker. Se você não tiver um, insira um endereço de e-mail fictício, como a@b.c. Esse e-mail é necessário para criar um segredo do Kubernetes, mas não é usado após a criação.

   --dry-run=true

   Inclua essa opção para criar apenas o valor secreto e não para criar e armazenar o objeto secreto em seu cluster.

   --output="jsonpath={.data.\.dockerconfigjson}"

   Obtenha somente o valor .dockerconfigjson por meio da seção de dados do segredo do Kubernetes.

   | base64 --decode > myregistryconfigjson

   Faça download dos dados de segredo decodificado para um arquivo local myregistryconfigjson.

2. Recupere o valor de segredo decodificado do segredo de extração global padrão e armazene o valor em um arquivo dockerconfigjson.

   oc get secret pull-secret -n openshift-config --output="jsonpath={.data.\.dockerconfigjson}" | base64 --decode > dockerconfigjson
   

3. Combine o arquivo do segredo de extração de registro privado myregistryconfigjson transferido por download com o arquivo do segredo de extração global padrão dockerconfigjson.

   jq -s '.[0] * .[1]' dockerconfigjson myregistryconfigjson > dockerconfigjson-merged
   

4. Atualize o segredo de extração global com o arquivo dockerconfigjson-merged combinado.

   oc set data secret/pull-secret -n openshift-config --from-file=.dockerconfigjson=dockerconfigjson-merged
   

5. Verifique se o segredo de extração global está atualizado. Verifique se o seu registro privado cada um dos registros padrão do Red Hat estão na saída do comando a seguir.

   oc get secret pull-secret -n openshift-config --output="jsonpath={.data.\.dockerconfigjson}" | base64 --decode
   

   Exemplo de saída

   {
       "auths": {
           "cloud.openshift.com": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "quay.io": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "registry.connect.redhat.com": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "registry.redhat.io": {
               "auth": "<encoded_string>",
               "email": "email@example.com"
           },
           "<private_registry>": {
               "username": "iamapikey",
               "password": "<encoded_string>",
               "email": "email@example.com",
               "auth": "<encoded_string>"
           }
       }
   }
   

6. Para selecionar as mudanças de configuração globais, recarregue todos os nós do trabalhador em seu cluster.

   1. Anote o ID dos nós do trabalhador em seu cluster.

      ibmcloud oc worker ls -c <cluster_name_or_ID>
      

   2. Para Clusters Clássicos Recarregar cada nó do trabalhador Você pode recarregar vários nós de trabalho incluindo várias opções de -w, mas certifique-se de deixar um número suficiente de nós de trabalho em execução ao mesmo tempo para que seus aplicativos evitem uma interrupção.

      ibmcloud oc worker reload -c <cluster_name_or_ID> -w <workerID_1> -w <workerID_2>
      

   3. Para clusters de VPC Substitua cada nó do trabalhador Antes de começar, certifique-se de que seu cluster tenha outros nós do trabalhador para que seus pods possam ser reprogramados e continuem sendo executados.

      ibmcloud oc worker replace --cluster <cluster_name_or_ID> --worker <worker_node_ID>
      

7. Depois que os nós do trabalhador estiverem novamente em um estado funcional, verifique se o segredo de extração global é atualizado em um nó do trabalhador.

   1. Inicie um pod de depuração para fazer login em um nó do trabalhador. Use o IP privado que você recuperou anteriormente para o <node_name>.

      oc debug node/<node_name>
      

   2. Mude o diretório-raiz para o host para que seja possível visualizar arquivos no nó do trabalhador.

      chroot /host
      

   3. Verifique se o arquivo de configuração do Docker tem as credenciais de registro que correspondem ao segredo de extração global que você configurou.

      vi /.docker/config.json
      

Atualização do segredo global de pull

Nós de trabalho RHCOS Nós de trabalho RHEL

Em clusters que usam workers do RHCOS ou uma combinação de workers do RHCOS e do RHEL, você pode concluir as etapas a seguir para atualizar o segredo de pull global no seu cluster Red Hat OpenShift on IBM Cloud.

Por padrão, seu cluster Red Hat OpenShift on IBM Cloud tem um segredo de extração de imagem global para os registros a seguir, de modo que os componentes padrão do Red Hat OpenShift podem ser implementados.

• cloud.openshift.com
• quay.io
• registry.connect.redhat.com
• registry.redhat.io

Não substitua o segredo de extração global por um segredo de extração que não tenha credenciais para os registros padrão do Red Hat. Se você fizer, os componentes padrão Red Hat OpenShift que estão instalados em seu cluster, como o OperatorHub, podem falhar porque eles não conseguem fazer pull de imagens desses registros.

1. Crie um segredo que tenha as credenciais do registro que você deseja usar.

   oc create secret docker-registry docker-auth-secret \
   --docker-server=REGISTRY \
   --docker-username=USERNAME \
   --docker-password=PASSWORD \
   --namespace kube-system
   

2. Crie um DaemonSet para aplicar o segredo em todos os nós de trabalho.

   ocp_release_pull_secret_image=$(oc get ds -n openshift-dns node-resolver -o jsonpath='{.spec.template.spec.containers[0].image}')
   cat << EOF | oc create -f -
   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: update-docker-config
     namespace: kube-system
     labels:
       app: update-docker-config
   spec:
     selector:
       matchLabels:
         name: update-docker-config
     template:
       metadata:
         labels:
           name: update-docker-config
       spec:
         initContainers:
           - command: ["/bin/sh", "-c"]
             args:
               - >
                 echo "Checking if RHEL or RHCOS host";
                 [[ -s /docker-config/.docker/config.json  ]] && CONFIG_PATH=/docker-config/.docker || CONFIG_PATH=/docker-config/root/.docker;
                 echo "Backing up or restoring config.json";
                 [[ -s \$CONFIG_PATH/config.json ]] && cp \$CONFIG_PATH/config.json \$CONFIG_PATH/config.json.bak || cp \$CONFIG_PATH/config.json.bak \$CONFIG_PATH/config.json;
                 echo "Merging secret with config.json";
                 /host/usr/bin/jq -s '.[0] * .[1]' \$CONFIG_PATH/config.json /auth/.dockerconfigjson > \$CONFIG_PATH/config.tmp;
                 mv \$CONFIG_PATH/config.tmp \$CONFIG_PATH/config.json;
                 echo "Sending signal to reload crio config";
                 pidof crio;
                 kill -1 \$(pidof crio)
             image: ${ocp_release_pull_secret_image}
             imagePullPolicy: IfNotPresent
             name: updater
             resources: {}
             securityContext:
               privileged: true
             volumeMounts:
               - name: docker-auth-secret
                 mountPath: /auth
               - name: docker
                 mountPath: /docker-config
               - name: bin
                 mountPath: /host/usr/bin
               - name: lib64
                 mountPath: /lib64
         containers:
           - resources:
               requests:
                 cpu: 0.01
             image: ${ocp_release_pull_secret_image}
             name: sleepforever
             command: ["/bin/sh", "-c"]
             args:
               - >
                 while true; do
                   sleep 100000;
                 done
         hostPID: true
         volumes:
           - name: docker-auth-secret
             secret:
               secretName: docker-auth-secret
           - name: docker
             hostPath:
               path: /
           - name: bin
             hostPath:
               path: /usr/bin
           - name: lib64
             hostPath:
               path: /lib64
               hostPathType: Directory
   EOF
   

3. Verifique se os pods estão em execução.

   oc get daemonset -n kube-system update-docker-config
   

Atualizando uma configuração de registro customizado containerd do IBM Cloud Kubernetes Service

Com o Kubernetes versão 1.22 ou mais recente, é possível usar arquivos de configuração containerd em nós do trabalhador para configurar a extração por meio de um registro de contêiner. É possível usar um daemonset para atualizar as configurações em todos os nós em um cluster, o que evita que as configurações sejam eliminadas quando os nós do trabalhador forem recarregados ou quando novos trabalhadores forem incluídos.

server = "https://docker.io"
[host."https://registry-1.docker.io"]
capabilities = ["pull", "resolve"]

apiVersion: apps/v1
kind: DaemonSet
metadata:
labels:
    name: containerd-dockerhub-registry-config
name: containerd-dockerhub-registry-config
namespace: kube-system
spec:
selector:
    matchLabels:
    name: containerd-dockerhub-registry-config
template:
    metadata:
    labels:
        name: containerd-dockerhub-registry-config
    spec:
    initContainers:
    - image: alpine:3.13.6
        name: containerd-dockerhub-registry-config
        command:
        - /bin/sh
        - -c
        - |
            #!/bin/sh
            set -uo pipefail
            cat << EOF > /etc/containerd/certs.d/docker.io/hosts.toml
            server = "https://docker.io"
            [host."https://registry-1.docker.io"]
            capabilities = ["pull", "resolve"]
            EOF
        volumeMounts:
        - mountPath: /etc/containerd/certs.d/docker.io/
        name: dockerhub-registry-config
    containers:
    - name: pause
        image: "us.icr.io/armada-master/pause:3.5"
        imagePullPolicy: IfNotPresent
    volumes:
    - name: dockerhub-registry-config
        hostPath:
        path: /etc/containerd/certs.d/docker.io/