**Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

# Implantar uma aplicação de amostra no Windows
<a name="sample-deployment-win"></a>

Neste tópico, você implementa uma aplicação de amostra em seu cluster nos nós do Windows.

## Pré-requisitos
<a name="_prerequisites"></a>
+ Um cluster existente do Kubernetes com pelo menos um nó. Se você não tiver um cluster do Amazon EKS existente, poderá implantar um usando um dos guias em [Começar a usar o Amazon EKS](getting-started.md). Você deve ter o [suporte ao Windows](windows-support.md) habilitado para o cluster e pelo menos um nó Windows para Amazon EC2.
+  `Kubectl`O instalado em seu computador. Para obter mais informações, consulte [Configurar o `kubectl` e o `eksctl`](install-kubectl.md).
+  `Kubectl`O configurado para se comunicar com o cluster. Para obter mais informações, consulte [Conecte o kubectl a um cluster de EKS criando um arquivo kubeconfig](create-kubeconfig.md).
+ Se você planeja implantar sua workload de exemplo no Fargate, deverá ter um [perfil do Fargate](fargate-profile.md) que inclua o mesmo namespace criado neste tutorial, que será `eks-sample-app`, a menos que você altere o nome. Se você criou um cluster com uma das guias no [Começar a usar o Amazon EKS](getting-started.md), será necessário criar um novo perfil ou adicionar o namespace ao perfil existente, pois o perfil criado nos guias de introdução não especifica o namespace usado neste tutorial. A VPC também deve conter pelo menos uma sub-rede privada.

Embora muitas variáveis possam ser alteradas nas etapas a seguir, recomendamos alterar apenas os valores das variáveis quando especificado. Depois de entender melhor os pods, as implantações e os serviços do Kubernetes, você pode experimentar alterar outros valores.

## Crie um namespace
<a name="_create_a_namespace"></a>

Um namespace permite agrupar recursos no Kubernetes. Para obter mais informações, consulte [Namespaces](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) na documentação do Kubernetes. Se você planeja implantar o exemplo de aplicação para [Simplificar o gerenciamento de computação com o AWS Fargate](fargate.md), certifique-se de que o valor de `namespace` em [Definir quais pods usam o AWS Fargate quando iniciados](fargate-profile.md) seja `eks-sample-app`.

```
kubectl create namespace eks-sample-app
```

## Crie uma implantação do Kubernetes
<a name="_create_a_kubernetes_deployment"></a>

Essa implantação de exemplo extrai uma imagem de contêiner de um repositório público e implanta três réplicas (pods individuais) dessa imagem em seu cluster. Para saber mais, consulte [Implantações](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) na documentação do Kubernetes.

1. Salve o conteúdo a seguir em um arquivo denominado `eks-sample-deployment.yaml`. Os contêineres da aplicação de exemplo não usam armazenamento em rede, mas pode haver aplicações que precisem. Para obter mais informações, consulte [Usar armazenamento de dados de aplicações para o cluster](storage.md).
   + `kubernetes.io/os: windows` `nodeSelector` significa que se você tivesse nós do Windows e do Linux (por exemplo) no cluster, a imagem só seria implantada nos nós do Windows. Para obter mais informações, consulte [Rótulos, anotações e taints conhecidos](https://kubernetes.io/docs/reference/labels-annotations-taints/) na documentação do Kubernetes.

     ```
     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: eks-sample-windows-deployment
       namespace: eks-sample-app
       labels:
         app: eks-sample-windows-app
     spec:
       replicas: 3
       selector:
         matchLabels:
           app: eks-sample-windows-app
       template:
         metadata:
           labels:
             app: eks-sample-windows-app
         spec:
           affinity:
             nodeAffinity:
               requiredDuringSchedulingIgnoredDuringExecution:
                 nodeSelectorTerms:
                 - matchExpressions:
                   - key: kubernetes.io/arch
                     operator: In
                     values:
                     - amd64
           containers:
           - name: windows-server-iis
             image: mcr.microsoft.com/windows/servercore:ltsc2019
             ports:
             - name: http
               containerPort: 80
             imagePullPolicy: IfNotPresent
             command:
             - powershell.exe
             - -command
             - "Add-WindowsFeature Web-Server; Invoke-WebRequest -UseBasicParsing -Uri 'https://dotnetbinaries.blob.core.windows.net/servicemonitor/2.0.1.6/ServiceMonitor.exe' -OutFile 'C:\\ServiceMonitor.exe'; echo '<html><body><br/><br/><marquee><H1>Hello EKS!!!<H1><marquee></body><html>' > C:\\inetpub\\wwwroot\\default.html; C:\\ServiceMonitor.exe 'w3svc'; "
           nodeSelector:
             kubernetes.io/os: windows
     ```

1. Aplique o manifesto de implantação ao seu cluster.

   ```
   kubectl apply -f eks-sample-deployment.yaml
   ```

## Criar um serviço
<a name="_create_a_service"></a>

Um serviço permite que você acesse todas as réplicas por meio de um único endereço IP ou nome. Para obter mais informações, consulte [Serviço](https://kubernetes.io/docs/concepts/services-networking/service/) na documentação do Kubernetes. Embora não esteja implementado na aplicação de exemplo, se houver aplicações que precisem interagir com outros serviços da AWS, recomendamos criar contas de serviço do Kubernetes para seus pods e associá-las a contas do AWS IAM. Ao especificar contas de serviço, seus pods podem ter apenas as permissões mínimas especificadas para elas para interagir com outros serviços. Para obter mais informações, consulte [Funções do IAM para contas de serviço](iam-roles-for-service-accounts.md).

1. Salve o conteúdo a seguir em um arquivo denominado `eks-sample-service.yaml`. O Kubernetes atribui ao serviço o seu próprio endereço IP acessível somente de dentro do cluster. Para acessar o serviço de fora do seu cluster, implante o [AWS Load Balancer Controller](aws-load-balancer-controller.md) para balancear a carga do tráfego de [aplicações](alb-ingress.md) ou [redes](network-load-balancing.md) para o serviço.

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: eks-sample-windows-service
     namespace: eks-sample-app
     labels:
       app: eks-sample-windows-app
   spec:
     selector:
       app: eks-sample-windows-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ```

1. Aplique o manifesto de serviço ao seu cluster.

   ```
   kubectl apply -f eks-sample-service.yaml
   ```

## Revisar os recursos criados
<a name="sample-app-view-namespace-win"></a>

1. Visualize todos os recursos no namespace `eks-sample-app`.

   ```
   kubectl get all -n eks-sample-app
   ```

   Veja abaixo um exemplo de saída.

   ```
   NAME                                               READY   STATUS    RESTARTS   AGE
   pod/eks-sample-windows-deployment-65b7669776-m6qxz   1/1     Running   0          27m
   pod/eks-sample-windows-deployment-65b7669776-mmxvd   1/1     Running   0          27m
   pod/eks-sample-windows-deployment-65b7669776-qzn22   1/1     Running   0          27m
   
   NAME                               TYPE         CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
   service/eks-sample-windows-service   ClusterIP    10.100.74.8     <none>        80/TCP    32m
   
   NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/eks-sample-windows-deployment 3/3     3            3           27m
   
   NAME                                                      DESIRED   CURRENT   READY   AGE
   replicaset.apps/eks-sample-windows-deployment-776d8f8fd8    3         3         3       27m
   ```

   Na saída, você verá o serviço e a implantação especificados nos manifestos de exemplo implantados nas etapas anteriores. Você também vê três pods. Isso ocorre porque `3` `replicas` foram especificadas no manifesto de exemplo. Para obter mais informações sobre pods, consulte [Pods](https://kubernetes.io/docs/concepts/workloads/pods/pod/) na documentação do Kubernetes. O Kubernetes cria automaticamente o recurso `replicaset`, mesmo que não esteja especificado nos manifestos de exemplo. Para obter mais informações sobre `ReplicaSets`, consulte [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/) na documentação do Kubernetes.
**nota**  
O Kubernetes mantém o número de réplicas especificado no manifesto. Se esta fosse uma implantação de produção e você quisesse que o Kubernetes escalasse horizontalmente o número de réplicas ou verticalmente os recursos de computação para os pods, você usaria as [implantações de pods de escala com o Horizontal Pod Autoscaler](horizontal-pod-autoscaler.md) e os [recursos de pods de ajuste com o Vertical Pod Autoscaler](vertical-pod-autoscaler.md) para fazer isso.

1. Veja os detalhes do serviço implantado.

   ```
   kubectl -n eks-sample-app describe service eks-sample-windows-service
   ```

   Veja abaixo um exemplo de saída.

   ```
   Name:              eks-sample-windows-service
   Namespace:         eks-sample-app
   Labels:            app=eks-sample-windows-app
   Annotations:       <none>
   Selector:          app=eks-sample-windows-app
   Type:              ClusterIP
   IP Families:       <none>
   IP:                10.100.74.8
   IPs:               10.100.74.8
   Port:              <unset>  80/TCP
   TargetPort:        80/TCP
   Endpoints:         192.168.24.212:80,192.168.50.185:80,192.168.63.93:80
   Session Affinity:  None
   Events:            <none>
   ```

   Na saída anterior, o valor de `IP:` é um endereço IP exclusivo que pode ser acessado de qualquer nó ou pod dentro do cluster, mas não pode ser acessado de fora do cluster. Os valores de `Endpoints` são endereços IP atribuídos de dentro da VPC aos pods que fazem parte do serviço.

1. Visualize os detalhes de um dos pods listados na saída quando você [visualizou o namespace](sample-deployment.md#sample-app-view-namespace) em uma etapa anterior. Substitua {{776d8f8fd8-78w66}} pelo valor retornado para um dos seus pods.

   ```
   kubectl -n eks-sample-app describe pod eks-sample-windows-deployment-65b7669776-m6qxz
   ```

   Exemplo abreviado de saída

   ```
   Name:         eks-sample-windows-deployment-65b7669776-m6qxz
   Namespace:    eks-sample-app
   Priority:     0
   Node:         ip-192-168-45-132.us-west-2.compute.internal/192.168.45.132
   [...]
   IP:           192.168.63.93
   IPs:
     IP:           192.168.63.93
   Controlled By:  ReplicaSet/eks-sample-windows-deployment-65b7669776
   [...]
   Conditions:
     Type              Status
     Initialized       True
     Ready             True
     ContainersReady   True
     PodScheduled      True
   [...]
   Events:
     Type    Reason     Age    From                                                 Message
     ----    ------     ----   ----                                                 -------
     Normal  Scheduled  3m20s  default-scheduler                                    Successfully assigned eks-sample-app/eks-sample-windows-deployment-65b7669776-m6qxz to ip-192-168-45-132.us-west-2.compute.internal
   [...]
   ```

   Na saída anterior, o valor de `IP:` é um IP exclusivo atribuído ao pod do bloco CIDR atribuído à sub-rede em que o nó está localizado. Se preferir atribuir a pods endereços IP de blocos CIDR diferentes, você pode alterar o comportamento padrão. Para obter mais informações, consulte [Implementar pods em sub-redes alternativas com rede personalizada](cni-custom-network.md). Você também pode ver que o agendador do Kubernetes agendou o pod no `Node` com o endereço IP {{192.168.45.132}}.
**dica**  
Em vez de usar a linha de comando, você pode visualizar muitos detalhes dos pods, serviços, implantações e outros recursos do Kubernetes no Console de gerenciamento da AWS. Para obter mais informações, consulte [Visualize os recursos do Kubernetes na seção Console de gerenciamento da AWS](view-kubernetes-resources.md).

## Executar um shell em um pod
<a name="_run_a_shell_on_a_pod"></a>

1. Execute um shell no pod que você descreveu na etapa anterior, substituindo {{65b7669776-m6qxz}} pelo ID de um de seus pods.

   ```
   kubectl exec -it eks-sample-windows-deployment-65b7669776-m6qxz -n eks-sample-app -- powershell.exe
   ```

1. No shell do pod, visualize a saída do servidor da Web instalado com a sua implantação em uma etapa anterior. Basta especificar o nome do serviço. Ele é resolvido para o endereço IP do serviço pelo CoreDNS, que é implantado com um cluster do Amazon EKS, por padrão.

   ```
   Invoke-WebRequest -uri eks-sample-windows-service/default.html -UseBasicParsing
   ```

   Veja abaixo um exemplo de saída.

   ```
   StatusCode        : 200
   StatusDescription : OK
   Content           : < h t m l > < b o d y > < b r / > < b r / > < m a r q u e e > < H 1 > H e l l o
                         E K S ! ! ! < H 1 > < m a r q u e e > < / b o d y > < h t m l >
   ```

1. No shell do pod, exiba o servidor DNS do pod.

   ```
   Get-NetIPConfiguration
   ```

   Resultado abreviado

   ```
   InterfaceAlias       : vEthernet
   [...]
   IPv4Address          : 192.168.63.14
   [...]
   DNSServer            : 10.100.0.10
   ```

   Na saída anterior, `10.100.0.10` é atribuído automaticamente como o servidor de DNS para todos os pods implantados no cluster.

1. Desconecte-se do pod digitando `exit`.

1. Ao terminar de usar a aplicação de exemplo, você poderá remover o namespace, o serviço e a implantação de exemplo com o comando a seguir.

   ```
   kubectl delete namespace eks-sample-app
   ```

## Próximas etapas
<a name="sample-deployment-win-next-steps"></a>

Após implantar a aplicação de exemplo, talvez você queira tentar alguns dos seguintes exercícios:
+  [Roteamento de aplicações e tráfego HTTP com Application Load Balancers](alb-ingress.md) 
+  [Roteamento de tráfego TCP e UDP com Network Load Balancers](network-load-balancing.md)