Esta página foi traduzida pela API Cloud Translation.

Implantar um app de servidor da Web conteinerizado

Neste tutorial, descrevemos como fazer upload de um aplicativo contêiner em um ambiente de appliance isolado do Google Distributed Cloud (GDC) e executar esse aplicativo no ambiente de appliance. Você vai aprender a criar projetos do Harbor, fazer upload de imagens para o Harbor e criar cargas de trabalho como parte deste tutorial. Uma carga de trabalho em contêineres é executada em um namespace de projeto.

O ambiente de appliance com isolamento físico do GDC vem com um registro do Harbor pré-configurado chamado tear-harbor em um projeto do GDC chamado tear. Você vai usar esse registro neste exemplo.

Este tutorial usa um app de servidor da Web de amostra disponível no Google Cloud Artifact Registry.

Objetivos

Envie uma imagem de contêiner para o registro gerenciado do Harbor.
Implante o app de contêiner de amostra no cluster.

Antes de começar

Verifique se você tem um projeto para gerenciar suas implantações em contêineres. Crie um projeto se você não tiver um.
Defina o namespace do projeto como uma variável de ambiente:
```
export NAMESPACE=PROJECT_NAMESPACE
```
Faça o download e instale a CLI gdcloud.
Peça ao administrador do IAM da organização para conceder a você os seguintes papéis:
- Papel de administrador de namespace (namespace-admin) para o namespace do projeto. Essa função é necessária para implantar cargas de trabalho de contêiner no seu projeto.
- Papel de leitor de instâncias do Harbor (harbor-instance-viewer) para o namespace do seu projeto. Essa função é necessária para visualizar e selecionar uma instância do Harbor.
- Função de criador de projetos do Harbor (harbor-project-creator) para o namespace do projeto. Esse papel é necessário para acessar e gerenciar um projeto do Harbor.
Faça login no cluster do Kubernetes e gere o arquivo kubeconfig dele com uma identidade de usuário. Verifique se você definiu o caminho do kubeconfig como uma variável de ambiente:
```
export KUBECONFIG=CLUSTER_KUBECONFIG
```

Criar projeto do Harbor no registro

O GDC oferece o Harbor como um serviço totalmente gerenciado que permite armazenar e gerenciar imagens de contêiner usando o Harbor.

Para usar o Harbor como um serviço, crie um projeto do Harbor na instância do registro tear-harbor para gerenciar as imagens de contêiner:

Você precisa do URL de tear-harbor. Liste o URL da instância:
```
gdcloud harbor instances describe tear-harbor --project=tear
```
A saída é semelhante a harbor-1.org-1.zone1.google.gdc.test.
Defina o URL da instância como uma variável para usar mais tarde no tutorial:
```
export INSTANCE_URL=INSTANCE_URL
```
Antes de criar o projeto, faça login no Harbor usando o URL da etapa anterior. Use um navegador para abrir este URL e faça login na instância do Harbor.
Crie o projeto do Harbor:
```
gdcloud harbor harbor-projects create HARBOR_PROJECT \
    --project=tear \
    --instance=tear-harbor
```
Substitua HARBOR_PROJECT pelo nome do projeto do Harbor a ser criado. Não é possível criar o projeto do Harbor em nenhum namespace de projeto. Você precisa usar o projeto tear.
Defina o nome do projeto do Harbor como uma variável para usar mais tarde no tutorial:
```
export HARBOR_PROJECT=HARBOR_PROJECT
```

Configurar Docker

Para usar o Docker no seu registro do Harbor, siga estas etapas:

Configure o Docker para confiar no Harbor como um serviço. Para mais informações, consulte Configurar o Docker para confiar na CA raiz do Harbor.
Configure a autenticação do Docker no Harbor. Para mais informações, consulte Configurar a autenticação do Docker para instâncias do registro do Harbor.
Como tear-harbor é um registro do Harbor pré-configurado, você precisa confiar no certificado assinado pela CA interna isolada do Google Distributed Cloud:
1. Peça ao seu IO as seguintes informações:
  1. o URL externo do cluster do Harbor.
  2. o arquivo .crt da CA interna do Google Distributed Cloud com isolamento físico. O arquivo é geralmente armazenado no plano de controle como um secret pelo nome trust-store-internal-only no namespace anthos-creds.
2. Semelhante à etapa anterior, crie uma pasta com o nome do URL externo do cluster do Harbor e mantenha o arquivo .crt dentro dela.

Criar um secret de extração de imagem do Kubernetes

Como você está usando um projeto particular do Harbor, é necessário criar um secret de pull de imagem do Kubernetes.

Adicione uma conta de robô do projeto do Harbor. Siga as etapas na interface do Harbor para criar a conta de robô e copiar o token secreto do robô: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.
Anote o novo nome da conta do projeto de robô, que tem a seguinte sintaxe:
```
<PREFIX><PROJECT_NAME>+<ACCOUNT_NAME>
```
Por exemplo, o formato do nome da conta do projeto do robô é semelhante a harbor@library+artifact-account.

Para mais informações sobre como encontrar o nome da conta do projeto do robô no Harbor, consulte a documentação do Harbor: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#view-project-robot-accounts.
Faça login no Docker com a conta de robô e o token secreto do projeto do Harbor:
```
docker login ${INSTANCE_URL}
```
Quando solicitado, insira o nome da conta do projeto do robô para o Username e o token secreto para o Password.
Defina um nome arbitrário para o secret de extração de imagem:
```
export SECRET=SECRET
```
Crie o secret necessário para o pull da imagem:
```
kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n NAMESPACE
```
Substitua:
- DOCKER_CONFIG: o caminho para o arquivo .docker/config.json.
- NAMESPACE: o namespace do secret que você criar.

Enviar imagem do contêiner para o registro gerenciado do Harbor

Neste tutorial, você vai baixar e enviar a imagem do servidor da Web nginx para o registro gerenciado do Harbor e usá-la para implantar um app de servidor da Web nginx de amostra em um cluster do Kubernetes. O app do servidor da Web nginx está disponível no Artifact Registry público Google Cloud .

Extraia a imagem nginx do Google Cloud Artifact Registry para sua estação de trabalho local usando uma rede externa:
```
docker pull gcr.io/cloud-marketplace/google/nginx:1.25
```
Defina o nome da imagem. O formato do nome completo de uma imagem é:
```
${INSTANCE_URL}/${HARBOR_PROJECT}/nginx
```

Marque a imagem local com o nome do repositório:

docker tag gcr.io/cloud-marketplace/google/nginx:1.25 ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

Envie a imagem do contêiner nginx para o registro gerenciado do Harbor:
```
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
```

Implantar o app de contêiner de amostra

Agora você está pronto para implantar a imagem do contêiner nginx no cluster do appliance.

O Kubernetes representa aplicativos como recursos Pod, que são unidades escalonáveis com um ou mais contêineres. O pod é a menor unidade implantável no Kubernetes. Normalmente, você implanta pods como um conjunto de réplicas que podem ser escalonadas e distribuídas juntas no cluster. Uma maneira de implantar um conjunto de réplicas é por meio de uma Deployment do Kubernetes.

Nesta seção, você cria uma Deployment do Kubernetes para executar o app de contêiner nginx no cluster. Essa implantação tem réplicas ou pods. Um pod Deployment contém apenas um contêiner: a imagem de contêiner nginx. Você também cria um recurso Service que oferece uma maneira estável para os clientes enviarem solicitações aos pods da sua Deployment.

Implante o servidor da Web nginx:

Crie e implante os recursos personalizados Deployment e Service do Kubernetes:

kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
        ports:
        - containerPort: 80
      imagePullSecrets:
      - name: ${SECRET}
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - port: 80
      protocol: TCP
  type: LoadBalancer
EOF

Verifique se os pods foram criados pela implantação:

kubectl get pods -l app=nginx -n ${NAMESPACE}

O resultado será assim:

NAME                                READY     STATUS    RESTARTS   AGE
nginx-deployment-1882529037-6p4mt   1/1       Running   0          1h
nginx-deployment-1882529037-p29za   1/1       Running   0          1h
nginx-deployment-1882529037-s0cmt   1/1       Running   0          1h

Crie uma política de rede para permitir todo o tráfego de rede para o namespace:

kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  annotations:
  name: allow-all
spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  podSelector: {}
  policyTypes:
  - Ingress
EOF

Exporte o endereço IP do serviço nginx:

  export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
      -n ${NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`

Teste o endereço IP do servidor nginx usando curl:
```
  curl http://$IP
```

A seguir

Leia a documentação sobre contêineres para saber como gerenciar contêineres.