Esta página foi traduzida pela API Cloud Translation.

Implemente uma app de servidor Web contentorizada

Este tutorial descreve como carregar uma aplicação de contentor num ambiente de dispositivo isolado do Google Distributed Cloud (GDC) e executar essa aplicação no ambiente do dispositivo. Vai aprender a criar projetos do Harbor, carregar imagens para o Harbor e criar cargas de trabalho como parte deste tutorial. Uma carga de trabalho contentorizada é executada num espaço de nomes do projeto.

O ambiente do dispositivo isolado do GDC inclui um registo do Harbor pré-configurado denominado tear-harbor num projeto do GDC denominado tear. Vai usar este registo neste exemplo.

Este tutorial usa uma app de servidor Web de exemplo disponível no Google Cloud Artifact Registry.

Objetivos

Envie uma imagem de contentor para o registo do Harbor gerido.
Implemente a app de contentor de exemplo no cluster.

Antes de começar

Certifique-se de que tem um projeto para gerir as implementações em contentores. Crie um projeto se não tiver um.
Defina o espaço de nomes do projeto como uma variável de ambiente:
```
export NAMESPACE=PROJECT_NAMESPACE
```
Transfira e instale a CLI gcloud.
Peça ao administrador de IAM da organização para lhe conceder as seguintes funções:
- Função de administrador do espaço de nomes (namespace-admin) para o espaço de nomes do seu projeto. Esta função é necessária para implementar cargas de trabalho de contentores no seu projeto.
- Função de visitante da instância do Harbor (harbor-instance-viewer) para o espaço de nomes do seu projeto. Esta função é necessária para ver e selecionar uma instância do Harbor.
- Função de criador do projeto do Harbor (harbor-project-creator) para o espaço de nomes do seu projeto. Esta função é necessária para aceder e gerir um projeto do Harbor.
Inicie sessão no cluster do Kubernetes e gere o respetivo ficheiro kubeconfig com uma identidade de utilizador. Certifique-se de que define o caminho do kubeconfig como uma variável de ambiente:
```
export KUBECONFIG=CLUSTER_KUBECONFIG
```

Crie um projeto do Harbor no registo

O GDC fornece o Harbor como um serviço, que é um serviço totalmente gerido que lhe permite armazenar e gerir imagens de contentores através do Harbor.

Para usar o Harbor como serviço, tem de criar um projeto do Harbor na instância do registo para gerir as suas imagens de contentores:tear-harbor

Precisa do URL do tear-harbor. Indique o URL da instância:
```
gdcloud harbor instances describe tear-harbor --project=tear
```
O resultado é 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, tem de iniciar sessão no Harbor através do URL do passo anterior. Use um navegador para abrir este URL e iniciar sessão 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 criar. Não pode criar o projeto do Harbor em nenhum espaço de nomes do projeto. Tem de 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
```

Configure o Docker

Para usar o Docker no seu registo do Harbor, conclua os seguintes passos:

Configure o Docker para confiar no Harbor como um serviço. Para mais informações, consulte o artigo Configure o Docker para confiar na AC raiz do Harbor.
Configure a autenticação do Docker para o Harbor. Para mais informações, consulte o artigo Configure a autenticação do Docker para instâncias do registo do Harbor.
Uma vez que o tear-harbor é um registo do Harbor pré-configurado, tem de confiar no certificado assinado pela AC interna isolada do Google Distributed Cloud:
1. Peça as seguintes informações à sua OI:
  1. O URL externo do cluster do Harbor.
  2. O ficheiro .crt da CA interna isolada do Google Distributed Cloud. Geralmente, o ficheiro é armazenado no plano de controlo como um segredo com o nome trust-store-internal-only no espaço de nomes anthos-creds.
2. Semelhante ao passo anterior, crie uma pasta com o nome do URL externo do cluster do Harbor e mantenha o ficheiro .crt dentro da pasta.

Crie um segredo de obtenção de imagens do Kubernetes

Uma vez que está a usar um projeto privado do Harbor, tem de criar um segredo de obtenção de imagens do Kubernetes.

Adicione uma conta de robô do projeto do Harbor. Siga os passos na IU 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.
Tenha em atenção o nome da nova conta do projeto de robôs, 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 de robôs 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.
Inicie sessão no Docker com a conta de robô do projeto do Harbor e o token secreto:
```
docker login ${INSTANCE_URL}
```
Quando lhe for pedido, introduza o nome da conta do projeto do robô para Username e o token secreto para Password.
Defina um nome arbitrário para o segredo de obtenção de imagens:
```
export SECRET=SECRET
```
Crie o segredo necessário para a obtenção da imagem:
```
kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n NAMESPACE
```
Substitua o seguinte:
- DOCKER_CONFIG: o caminho para o ficheiro .docker/config.json.
- NAMESPACE: o espaço de nomes do segredo que criar.

Envie a imagem do contentor para o registo do Harbor gerido

Para este tutorial, vai transferir e enviar a imagem do servidor Web nginx para o registo do Harbor gerido e usá-la para implementar uma app de servidor Web nginx de exemplo num cluster do Kubernetes. A app do servidor Web nginx está disponível no Artifact Registry público. Google Cloud

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

Etiquete 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 contentor nginx para o seu registo do Harbor gerido:
```
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
```

Implemente a app do contentor de exemplo

Já pode implementar a imagem do contentor nginx no cluster do dispositivo.

O Kubernetes representa as aplicações como recursos Pod, que são unidades escaláveis que contêm um ou mais contentores. O pod é a unidade implementável mais pequena no Kubernetes. Normalmente, implementa pods como um conjunto de réplicas que podem ser dimensionadas e distribuídas em conjunto no cluster. Uma forma de implementar um conjunto de réplicas é através de um Deployment do Kubernetes.

Nesta secção, cria um Kubernetes Deployment para executar a app de contentor nginx no seu cluster. Esta implementação tem réplicas ou pods. Um pod Deployment contém apenas um contentor: a imagem do contentor nginx. Também cria um recurso Service que oferece aos clientes uma forma estável de enviar pedidos para os pods do seu Deployment.

Implemente o servidor Web nginx:

Crie e implemente 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 implementação:

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

O resultado é semelhante ao seguinte:

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 espaço de nomes:

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 com curl:
```
  curl http://$IP
```

O que se segue?

Leia a documentação sobre contentores para obter informações sobre como gerir contentores.