Construindo imagens

É possível construir suas imagens de várias formas, incluindo os seguintes serviços IBM Cloud.

IBM Cloud Code Engine

O Code Engine suporta a construção de imagens por meio de um Dockerfile e do Cloud Native Buildpacks e automaticamente enviando por push as imagens para IBM Cloud® Container Registry. Para obter mais informações, consulte Planejando a sua construção.

Pipelines Tekton

O serviço Continuous Delivery inclui várias tarefas Tekton que podem ser referenciadas nos pipelines para a construção de imagens. Para obter mais informações, consulte Pipelines Tekton.

Implementando contêineres por meio de um fluxo de imagem existente no registro interno

Você pode implantar um aplicativo a partir de um fluxo de imagens existente que o administrador do seu cluster tenha configurado no registro interno do seu cluster do Red Hat OpenShift. Por exemplo, seu administrador de cluster pode ter configurado o fluxo de imagem para importar uma imagem de um registro privado externo, como IBM Cloud Container Registry.

Implementando contêineres de uma imagem do IBM Cloud Container Registry no projeto default do Red Hat OpenShift

É possível implementar contêineres em seu cluster por meio de uma imagem pública fornecida pela IBM ou de uma imagem privada que é armazenada em seu namespace do IBM Cloud Container Registry. Para obter mais informações sobre como seu cluster acessa imagens de registro, consulte Compreendendo como seu cluster está autorizado a fazer pull de imagens do IBM Cloud Container Registry.

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.

4. Crie um arquivo de configuração de implementação denominado <deployment>.yaml.

5. Defina a implementação e a imagem a serem usadas por meio de seu projeto no IBM Cloud Container Registry.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: <deployment>
   spec:
     replicas: <number_of_replicas>
     selector:
       matchLabels:
         app: <app_name>
     template:
       metadata:
         labels:
           app: <app_name>
       spec:
         containers:
         - name: <app_name>
           image: <region>.icr.io/<project>/<image>:<tag>
   

   <deployment>

   Dê um nome à sua implementação.

   <number_of_replicas>

   Insira o número de pods de réplica que a implementação cria.

   app: <app_name>

   Use o nome do seu app como um rótulo para o contêiner.

   name: <app_name>

   Dê um nome ao seu contêiner, como o nome do seu rótulo app.

   image: <region>.icr.io/project>/image>:tag>

   Substitua as variáveis da URL da imagem pelas informações para sua imagem:

   region>: o terminal de API do IBM Cloud Container Registry regional para o domínio de registro. Para listar o domínio para a região na qual você está com login efetuado, execute ibmcloud cr api.

   namespace>: O espaço de nomes de registro. Para obter suas informações de namespace, execute ibmcloud cr namespace-list.

   image>:tag>: A imagem e a tag que você deseja utilizar para o contêiner. Para listar as imagens que estão disponíveis em seu namespace de registro, execute ibmcloud cr images.

6. Crie a implementação em seu cluster.

   oc apply -f <deployment>.yaml
   

Implementando contêineres por meio de uma imagem criptografada

Implemente contêineres de uma imagem criptografada para o seu cluster usando o complemento de cluster do Image Key Synchronizer.

Em clusters que executam o Red Hat OpenShift 4.5 ou versões posteriores, o ambiente de execução de contêineres CRI-O oferece suporte ao uso de imagens de contêiner criptografadas. As imagens de contêiner criptografadas são imagens Open Container Initiative (OCI) que contêm conteúdo de camada criptografada. Em vez de assegurar uma imagem para desenvolvedores individuais, como um desenvolvedor usando segredos de extração de imagem para extrair imagens de um registro, é possível ativar a criptografia de imagem para um cluster específico. Dessa forma, é possível assegurar que as imagens criptografadas sejam executadas somente nesses clusters específicos que tenham a chave de decriptografia de imagem.

Para executar um app usando uma imagem criptografada, deve-se compartilhar a chave para decriptografar a imagem com o tempo de execução do contêiner nos nós do trabalhador no cluster. Ao ativar o complemento do Image Key Synchronizer em seu cluster, o conjunto de daemon do sincronizador é implementado no projeto image-key-synchronizer. Em seguida, é possível criar segredos do Kubernetes que contêm as chaves de decriptografia de imagem nesse projeto. O complemento inclui as chaves em um diretório específico nos nós do trabalhador no qual o tempo de execução do contêiner pode acessar e usar as chaves para decriptografar imagens de contêiner. Observe que o complemento do Image Key Synchronizer também suporta chaves privadas que são primeiramente agrupadas por uma chave raiz que é armazenada em uma instância do IBM® Key Protect.

Antes de Iniciar

1. Faça download e instale os clientes da CLI para as ferramentas de software livre a seguir:

   • OpenSSL, para gerar um par de chaves RSA.
   • Docker Engine CLI, para baixar localmente imagens de um repositório de imagens.
   • Skopeo, para criptografar imagens de container OCI.

2. Acesse o seu Red Hat OpenShift cluster.

3. Opcional: ao criar um par de chaves públicas e privadas para a criptografia de imagem, é possível fornecer a chave privada diretamente em um segredo ou agrupar primeiro a chave privada usando uma chave raiz do Key Protect ou um serviço de gerenciamento de chaves (KMS). Para se preparar para agrupar a chave privada:

   1. Instale o plug-in da CLI do Key Protect.
   2. Crie uma instância de serviço do Key Protect.
   3. Crie uma chave raiz do Key Protect.
   4. Obtenha os valores a seguir para a sua instância do Key Protect:
      • O ID da instância de serviço.
      • A chave de API para o ID da instância de serviço.
      • A URL do terminal em serviço.
   5. Crie um segredo do Kubernetes chamado keyprotect-config que contém os valores que você recuperou. O complemento do Image Key Synchronizer usa as variáveis de ambiente nesse segredo para se autenticar com a sua instância do Key Protect.

       apiVersion: v1
       kind: Secret
       metadata:
         name: keyprotect-config
         namespace: image-key-synchronizer
       type: Opaque
       stringData:
         config.json: |
             {
                 "keyprotect-url":"<service_endpoint>",
                 "instance-id": "<service_instance_ID>",
                 "apikey": "<service_instance_ID_API_key>"
             }
       ```
   

Para implementar contêineres que usam imagens criptografadas:

1. Atualize o plug-in “ container-service ” para a versão mais recente.

   ibmcloud update && ibmcloud plugin update container-service
   

2. Ative o complemento do Image Key Synchronizer.

   ibmcloud oc cluster addon enable image-key-synchronizer -c CLUSTER_NAME_OR_ID
   

3. Verifique se o conjunto de daemons addon-image-key-synchronizer foi criado com sucesso no projeto image-key-synchronizer em seu cluster.

   oc get ds addon-image-key-synchronizer -n image-key-synchronizer
   

4. Use o openssl para gerar um par de chaves RSA privada e pública.

   openssl genrsa -out myprivatekey.pem
   openssl rsa -in myprivatekey.pem -pubout -out mypubkey.pem
   

5. Forneça a chave privada diretamente em um segredo, ou primeiro agrupe a chave privada usando uma chave raiz de um serviço de gerenciamento de chaves (KMS), como o Key Protect. Depois de criar o segredo no projeto image-key-synchronizer, o complemento do Image Key Synchronizer copia automaticamente a chave privada no diretório /etc/crio/keys/synced em seus nós do trabalhador.

   • Para fornecer a chave privada diretamente: salve a chave privada como um segredo de Kubernetes no projeto image-key-synchronizer.

       oc create -n image-key-synchronizer secret generic --type=key --from-file=myprivatekey.pem <secret_name>
       ```
   - **Para agrupar a chave privada usando uma chave raiz do Key Protect**:
       1. Codifique sua chave privada em base64 e copie a saída.
   
           ```sh {: pre}
           cat myprivatekey.pem | base64
           ```
       2. Use o plug-in da CLI do Key Protect para agrupar a chave privada codificada em base64 com a sua chave raiz. Na saída, copie o texto cifrado da chave privada agrupada.
   
           ```sh {: pre}
           ibmcloud kp key wrap ROOT_KEY_ID -p BASE64_ENCODED_PRIVATE_KEY
           ```
       3. Salve a chave privada agrupada como um segredo do Kubernetes no projeto `image-key-synchronizer`.
   
           ```yaml {: pre}
           apiVersion: v1
           kind: Secret
           type: kp-key
           metadata:
             name: <secret_name>
             namespace: image-key-synchronizer
           stringData:
             rootkeyid: "<root_key_ID>"
             ciphertext: "<wrapped_private_key_cipertext>"
           ```
       4. Crie o segredo.
   
           ```sh {: pre}
           oc apply -n image-key-synchronizer -f <secret_name>.yaml
           ```
   

6. Use o docker para extrair localmente uma imagem OCI. Substitua <source_image> pelo repositório da imagem e <tag> pela tag da imagem que você deseja utilizar, como latest.

   docker pull <source_image>:<tag>
   

7. Use o skopeo para criptografar a imagem local. Este comando copia a imagem OCI que você extraiu anteriormente, usa sua chave pública para criptografar a imagem e a salva em um arquivo local diferente. Considere nomear a imagem criptografada <source_image>_encrypted para fácil identificação.

   skopeo copy --encryption-key jwe:./mypubkey.pem <source_image>:<tag> <source_image>_encrypted:<tag>
   

8. Opcional: para verificar localmente se a imagem é criptografada, é possível tentar decriptografar a imagem com uma chave incorreta.

   1. Gere uma nova chave privada.

       openssl genrsa --out wrongkey.pem 1024
       ```
   2. Tentativa de usar essa nova chave para decriptografar a imagem. O comando de decriptografia falha porque a chave privada incorreta foi especificada.
   
   ```sh {: pre}
       skopeo copy --decryption-key ./wrongkey.pem <source_image>_encrypted:<tag> <source_image>_decrypted:<tag>
       ```
   

9. Opcional: envie por push a imagem criptografada para o IBM Cloud Container Registry, que suporta imagens OCI criptografadas.

10. Especifique a imagem criptografada em sua implementação do app. Por exemplo, se você tiver enviado a imagem criptografada por push para o IBM Cloud Container Registry, será possível seguir o exemplo em Implementando contêineres de uma imagem do IBM Cloud Container Registry no projeto default do Red Hat OpenShift. Ao criar a implementação em seu cluster, o tempo de execução do contêiner usa a chave de decriptografia privada no diretório /etc/crio/keys/synced para decriptografar a imagem antes de executá-la.

11. Para quaisquer imagens subsequentes que você deseja criptografar, é possível usar a mesma chave pública para criptografar as imagens com o Skopeo ou repetir essas etapas para usar um par de chaves públicas e privadas diferentes.

Se você decidir desativar o complemento posteriormente, o conjunto de daemons addon-image-key-synchronizer será removido, mas o projeto image-key-synchronizer e quaisquer segredos que você tenha criado nesse projeto não serão removidos, e o ambiente de execução do contêiner ainda poderá usar os segredos para executar imagens criptografadas. Para remover também as chaves dos nós do trabalhador, deve-se excluir os segredos correspondentes do projeto image-key-synchronizer antes de desativar o complemento.

Para consultar a lista de alterações de cada versão do complemento Image Key Synchronizer, consulte o registro de alterações do complemento Image Key Synchronizer em IBM Cloud.

Referindo-se à imagem pull secret em sua implementação pod

Se o administrador do cluster não armazenou o segredo de extração de imagem na conta de serviço do Kubernetes, todas as implementações que não especificarem uma conta de serviço não poderão usar o segredo de extração de imagem para implementar contêineres. Em vez disso, é possível definir um segredo de extração de imagem em sua implementação de pod. Quando você se refere ao segredo de extração de imagem em uma implementação de pod, o segredo de extração da imagem é válido para este pod apenas e não pode ser compartilhado com os pods no projeto Red Hat OpenShift.

Antes de Iniciar

• Criar um segredo de extração de imagem para acessar imagens em outros registros ou em projetos do Red Hat OpenShift diferentes de default.
• Acesse o seu Red Hat OpenShift cluster.

Para referir-se ao segredo de extração de imagem na implementação de pod,

1. Crie um arquivo de configuração de pod que seja denominado mypod.yaml.

2. Defina o pod e o segredo de pull de imagem para acessar imagens no IBM Cloud Container Registry.

   Para acessar uma imagem privada,

   apiVersion: v1
   kind: Pod
   metadata:
     name: mypod
   spec:
     containers:
       - name: <container_name>
         image: <region>.icr.io/<namespace_name>/<image_name>:<tag>
     imagePullSecrets:
       - name: <secret_name>
   

   Para acessar uma imagem pública da IBM Cloud,

   apiVersion: v1
   kind: Pod
   metadata:
     name: mypod
   spec:
     containers:
       - name: <container_name>
         image: icr.io/<image_name>:<tag>
     imagePullSecrets:
       - name: <secret_name>
   

   container_name>

   O nome do contêiner a ser implementado em seu cluster. namespace_name>: O espaço de nomes de registro no qual a imagem é armazenada. Para listar os namespaces disponíveis, execute ibmcloud cr namespace-list. image_name>: O nome da imagem a ser utilizada. Para listar as imagens disponíveis em uma conta do IBM Cloud, execute ibmcloud cr image-list. tag>: A versão da imagem que você deseja utilizar. Se nenhuma tag for especificada, a imagem identificada como a mais recente será usada por padrão. <secret_name>: O nome do segredo de extração de imagem criado anteriormente.

3. Salve as mudanças.

4. Crie a implementação em seu cluster.

   oc apply -f mypod.yaml
   

Enviando por push imagens para o IBM Cloud Container Registry

Após o administrador do cluster configurar um registro de imagem com o IBM Cloud Container Registry, você pode armazenar de forma segura e compartilhar imagens do Docker com outras usuários adicionando imagens ao seu namespace.

Por exemplo, é possível que você puxe uma imagem de qualquer origem de registro privado ou público e, em seguida, identificá-la para uso posterior no IBM Cloud Container Registry. Ou é possível que você envie por push uma imagem do Docker com a qual você trabalha para o seu namespace para que outros usuários possam acessar a imagem. Para iniciar, consulte Incluindo imagens em seu namespace.

Gerenciando a segurança de imagens no IBM Cloud Container Registry com o Vulnerability Advisor

O Vulnerability Advisor verifica o status de segurança de imagens de contêiner que são fornecidas pela IBM, terceiros ou incluídas no namespace do IBM Cloud Container Registry da sua organização.

Quando você inclui uma imagem em um namespace, ela é automaticamente varrida pelo Vulnerability Advisor para detectar problemas de segurança e potenciais vulnerabilidades. Se problemas de segurança forem localizados, instruções serão fornecidas para ajudá-lo a corrigir a vulnerabilidade relatada. Para começar, consulte Gerenciando a segurança da imagem com o Vulnerability Advisor.

Configuração de conteúdo confiável para imagens de contêiner

É possível construir contêineres de imagens confiáveis assinadas e armazenadas no IBM Cloud Container Registry e evitar as implementações de imagens não assinadas ou vulneráveis.

1. Conectar imagens para o conteúdo confiável. Depois de configurar a confiança para suas imagens, será possível gerenciar o conteúdo confiável e os assinantes que podem enviar imagens por push para seu registro.
2. Para cumprir uma política para que somente imagens assinadas possam ser usadas para construir contêineres em seu cluster, instale o projeto Portieris de software livre.
3. Os usuários do cluster podem implementar apps que são construídos por meio de imagens confiáveis.
   1. Implemente no namespace default do Kubernetes.
   2. Implemente a um espaço de nomes do Kubernetes diferente ou de uma região ou conta da IBM Cloud diferente.

Ativando o cumprimento de segurança da imagem em seu cluster

Ao ativar o cumprimento de segurança da imagem em seu cluster, você instala o projeto Portieris Kubernetes de software livre. Em seguida, é possível criar políticas de imagem para evitar que pods que não atendem às políticas, como imagens não assinadas, sejam executados no cluster.

Para obter mais informações, consulte a Documentação do Portieris.

Imagens mutantes: por padrão, o Portieris usa o controlador de admissão MutatingAdmissionWebhook para mutar sua imagem para referir-se à imagem por uma compilação em vez de uma tag. No entanto, você pode ter alguma tecnologia de implementação que rejeita uma imagem mutante. Nesse caso, é possível usar a opção de mutação de imagem e a política para mudar o comportamento padrão.