Esta página foi traduzida pela API Cloud Translation.

Criar um serviço e uma entrada

Neste documento, mostramos como criar um objeto Entrada do Kubernetes em um cluster de usuário para o Google Distributed Cloud. Uma Entrada é associada a um ou mais Serviços, e cada um deles está associado a um conjunto de pods.

Antes de começar

Consiga uma conexão SSH para a estação de trabalho do administrador

Criar uma implantação

Veja o manifesto de uma implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
    spec:
      containers:
      - name: hello-world
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"
      - name: hello-kubernetes
        image: "gcr.io/google-samples/node-hello:1.0"
        env:
        - name: "PORT"
          value: "8080"

Para este exercício, é importante entender os pontos a seguir sobre o manifesto de implantação:

Cada pod que pertence à implantação tem o rótulo greeting: hello.
Cada pod tem dois contêineres.
Os campos env especificam que os contêineres hello-app detectam atividade na porta TCP 50000 e os contêineres node-hello detectam atividade na porta TCP 8080. Para hello-app, é possível ver o efeito da variável de ambiente PORT analisando o código-fonte hello-app.

Copie o manifesto em um arquivo denominado hello-deployment.yaml e crie a implantação:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f hello-deployment.yaml

em que USER_CLUSTER_KUBECONFIG é o caminho do arquivo kubeconfig do cluster de usuário.

Expor a implantação com um Serviço

Se quiser oferecer uma forma estável para os clientes enviarem solicitações aos pods da implantação, crie um Serviço.

Veja aqui um manifesto para um Serviço que expõe a implantação a clientes dentro do cluster:

apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  type: ClusterIP
  selector:
    greeting: hello
  ports:
  - name: world-port
    protocol: TCP
    port: 60000
    targetPort: 50000
  - name: kubernetes-port
    protocol: TCP
    port: 60001
    targetPort: 8080

Copie o manifesto para um arquivo chamado hello-service.yaml e crie o Service:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f hello-service.yaml

Veja o Serviço:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get service hello-service --output yaml

A saída mostra o valor de clusterIP que foi fornecido ao serviço. Exemplo:

apiVersion: v1
kind: Service
metadata:
  annotations:
    ...
spec:
  clusterIP: 10.96.14.249
  clusterIPs:
  - 10.96.14.249
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000
  - name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080
  selector:
    greeting: hello
  sessionAffinity: None
  type: ClusterIP
status:
  loadBalancer: {}

Na saída anterior, o campo ports é uma matriz de objetos ServicePort do Kubernetes: um chamado world-port e outro chamado kubernetes-port.

Veja como um cliente pode chamar o Serviço:

Usando world-port: um cliente que executa um dos nós do cluster envia uma solicitação para clusterIP em port. Neste exemplo, 10.96.14.249:60000. A solicitação é encaminhada a um pod membro em targetPort. Neste exemplo, POD_IP_ADDRESS:50000.
Usando kubernetes-port: um cliente que executa um dos nós do cluster envia uma solicitação para clusterIP em port. Neste exemplo, 10.96.14.249:60001. A solicitação é encaminhada a um pod membro em targetPort. Neste exemplo, POD_IP_ADDRESS:8080.

Componentes da Entrada

Estes são alguns dos componentes do cluster relacionados à Entrada:

A implantação de istio-ingress. Esse é o proxy de entrada. O proxy de entrada encaminha o tráfego para os Serviços internos de acordo com as regras especificadas em um objeto de Entrada.
O serviço istio-ingress. Este serviço expõe a implantação istio-ingress.
A implantação istiod. Este é o controlador de Entrada. O controlador de entrada observa a criação de objetos Ingress e configura o proxy de entrada de acordo.

Criar uma Entrada

Veja aqui um manifesto de uma Entrada:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - http:
      paths:
      - path: /greet-the-world
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60000
      - path: /greet-kubernetes
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60001

Copie o manifesto em um arquivo chamado my-ingress.yaml e crie a Entrada:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-ingress.yaml

Ao criar um cluster de usuário, especifique um valor para loadbalancer.ingressVip no arquivo de configuração do cluster. Esse endereço IP é configurado no balanceador de carga do cluster. Quando você cria uma Entrada, ela recebe esse mesmo VIP como o endereço IP externo dela.

Quando um cliente envia uma solicitação ao VIP de Entrada do cluster de usuário, a solicitação é roteada para o balanceador de carga. O balanceador de carga usa o Serviço istio-ingress para encaminhar a solicitação ao proxy de Entrada, que é executada no cluster de usuário. O Serviço de entrada está configurado para encaminhar a solicitação a back-ends diferentes, dependendo do caminho no URL da solicitação.

Caminho `/greet-the-world`

No manifesto de Entrada, há uma regra que diz que o caminho /greet-the-world está associado a serviceName: hello-service e servicePort: 60000. Lembre-se de que 60000 é o valor da port na seção world-port do Serviço hello-service.

- name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000

O Serviço de Entrada encaminha a solicitação para clusterIP:50.000. Em seguida, a solicitação vai para um dos pods membros do serviço hello-service. O contêiner, nesse pod, que detecta a porta 50000 exibe uma mensagem Hello World!.

Caminho `/greet-kubernetes`

No manifesto de Entrada, há uma regra que diz que o caminho /greet-kubernetes está associado a serviceName: hello-service e servicePort: 60001. Lembre-se de que 60001 é o valor da port na seção kubernetes-port do Serviço hello-service.

- name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080

O Serviço de Entrada encaminha a solicitação para clusterIP: 8080. Em seguida, a solicitação vai para um dos pods membros do serviço hello-service. O contêiner, nesse pod, que detecta a porta 8080 exibe uma mensagem Hello Kubernetes!.

Testar a Entrada

Teste o Entrada usando o caminho /greet-the-world:

curl USER_CLUSTER_INGRESS_VIP/greet-the-world

Substitua USER_CLUSTER_INGRESS_VIP pelo endereço IP externo da Entrada.

A saída mostra uma mensagem Hello, world!:

Hello, world!
Version: 2.0.0
Hostname: ...

Teste o Entrada usando o caminho /greet-kubernetes:

curl USER_CLUSTER_INGRESS_VIP/greet-kubernetes

A saída mostra uma mensagem Hello, Kubernetes!:

Hello Kubernetes!

Configurar HTTPS para a Entrada

Se você quiser aceitar solicitações HTTPS dos clientes, o proxy de Entrada precisará ter um certificado para provar a identidade dele aos clientes. Esse proxy também precisa ter uma chave privada para concluir o handshake HTTPS.

O exemplo a seguir usa essas entidades:

Proxy de entrada: participa do handshake HTTPS e, em seguida, encaminha os pacotes para os pods membros do serviço hello-service.
Domínio do serviço hello-service: altostrat.com na organização de exemplo

Siga estas etapas:

Crie um certificado raiz e uma chave privada. Este exemplo usa uma autoridade certificadora raiz de root.ca.example.com na organização de exemplo da CA raiz.
```
openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=Root CA Example Inc./CN=root.ca.example.com' -keyout root-ca.key -out root-ca.crt
```

Crie uma solicitação de assinatura de certificado:

openssl req -out server.csr -newkey rsa:2048 -nodes -keyout server.key -subj "/CN=altostrat.com/O=Example Org"

Crie um certificado de exibição para o proxy de entrada.
```
openssl x509 -req -days 365 -CA root-ca.crt -CAkey root-ca.key -set_serial 0 -in server.csr -out server.crt
```
Você criou estes seguintes certificados e chaves:
- root-ca.crt: certificado da CA raiz;
- root-ca.key: chave privada da CA raiz;
- server.crt: certificado de exibição do proxy de entrada;
- server.key: chave privada do proxy de entrada;
Crie um secret do Kubernetes que contenha o certificado e a chave de exibição.
```
kubectl create secret tls example-server-creds --key=server.key --cert=server.crt --namespace gke-system
```
O secret resultante é denominado example-server-creds.

Observação: secrets do TLS precisam ser definidos no namespace gke-system.

Criar uma implantação e um serviço

Se você criou uma implantação e um Serviço na parte HTTP deste guia, deixe-os no lugar. Se você não fez isso, crie-os agora seguindo as etapas descritas para HTTP.

Criar uma Entrada

Se você já tiver criado uma Entrada na parte HTTP, exclua-a antes de continuar.

Exclua a Entrada:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete ingress my-ingress

Para lidar com o tráfego do serviço que você criou anteriormente, crie uma nova Entrada que tenha uma seção tls. Isso ativará o HTTPS entre os clientes e o proxy de entrada.

Veja aqui um manifesto de uma Entrada:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress-2
spec:
  tls:
  - hosts:
    - altostrat.com
    secretName: example-server-creds
  rules:
  - host: altostrat.com
    http:
      paths:
      - path: /greet-the-world
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60000
      - path: /greet-kubernetes
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60001

Salve o manifesto em um arquivo chamado my-ingress-2.yaml e crie a Entrada:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-ingress-2.yaml

Confirme por teste.

Teste o caminho /greet-the-world:

curl -v --resolve altostrat.com:443:USER_CLUSTER_INGRESS_VIP https://altostrat.com/greet-the-world --cacert root-ca.crt

Saída:

Hello, world!
Version: 2.0.0
Hostname: hello-deployment-5ff7f68854-wqzp7

Teste o caminho /greet-kubernetes:

curl -v --resolve altostrat.com:443:USER_CLUSTER_INGRESS_VIP https://altostrat.com/greet-kubernetes --cacert root-ca.crt

Saída:

Hello Kubernetes!

Limpar

Exclua o Entrada:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete ingress INGRESS_NAME

Substitua INGRESS_NAME pelo nome da Entrada, como my-ingress ou my-ingress-2.

Exclua o Serviço:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete service hello-service

Exclua a implantação:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete deployment hello-deployment

Criar um serviço e uma entrada

Antes de começar

Criar uma implantação

Expor a implantação com um Serviço

Componentes da Entrada

Criar uma Entrada

Caminho /greet-the-world

Caminho /greet-kubernetes

Testar a Entrada

Configurar HTTPS para a Entrada

Criar uma implantação e um serviço

Criar uma Entrada

Limpar

Caminho `/greet-the-world`

Caminho `/greet-kubernetes`