Para garantir balanceamento de carga, escalabilidade e aumentar a tolerância a falhas, podem ser usadas ferramentas auxiliares - orquestradores. Entre eles, o serviço Kubernetes agora é muito popular. A maneira mais fácil de experimentá-lo na prática é implantá-lo na nuvem, o que faremos hoje.

Nota: continuamos a série de publicações de versões completas de artigos da revista Hacker. Ortografia e pontuação do autor salvas.

Expandir AKS

Vamos ao portal do Azure , clique em "Criar recurso" e localizamos um serviço chamado Serviço Kubernetes.

Escolha o nome e prefixo DNS a seu gosto. O nome afeta como você acessará seu cluster, mas o prefixo afeta seu endereço FQDN.

Atualmente, a máquina virtual mais barata custa pouco mais de US $ 30 por mês.

A segunda etapa é criar uma entidade de serviço. O principal de serviço é um tipo de conta de serviço sob a qual determinadas tarefas específicas podem ser executadas. A vantagem é que os direitos dessa conta podem ser limitados. Além disso, você pode criar qualquer número dessas contas (enquanto o número de contas regulares é limitado por assinatura). Você pode encontrar as contas principais de serviço criadas no Active Directory entre os Registros de aplicativos.

RBAC (controle de acesso baseado em função) é a capacidade de restringir ou fornecer acesso a recursos específicos (ou grupos de recursos). Ou seja, você pode distinguir quais usuários da sua assinatura têm direitos de acesso e quais não.

No momento, o processo leva cerca de 20 minutos, mas tudo pode depender da configuração.

Encontre guias oficiais seguindo os links
Crie um cluster AKS usando o portal
Criando um cluster AKS usando a CLI

Para trabalhar, precisamos da linha de comando do Azure - CLI (Command Line Interface). Ele pode ser instalado no Windows e no macOS ou Linux. Pessoalmente, prefiro usar o Azure Cloud Shell. Esta é a linha de comando que é executada na página do portal do Azure carregada no navegador. Para funcionar, requer o armazenamento de blobs criado. Seu custo será de alguns centavos por mês e, portanto, prefiro não me preocupar em instalar a CLI no meu carro.

O Kubernetes suporta várias tecnologias de contêiner, mas vamos ver a mais popular - Docker. O docker.hub permite armazenar uma imagem do docker privado gratuitamente. Se você precisar de mais, poderá colocá-los por dinheiro. Mas, por dinheiro, uma imagem de janela de encaixe privada pode ser colocada no Registro de Contêiner do Azure. Agora, os preços começam em US $ 5 por mês (para SKU básico).

Criei um serviço ACR sob o nome myservice. Se você também decidir usar o ACR, criando um serviço, você precisará obter as chaves.

Em seguida, será possível efetuar login executando o comando:

docker login myservice.azurecr.io 

Digite o nome de usuário (myservice) e a senha tirada do portal (PJSeyO9 = lCMRDI7dGkz68wjhFGRGxSY3)

Agora, indo para o diretório com o projeto, será possível criar uma imagem enquanto a marca com a tag desejada. Depois disso, envie-o para o serviço em nuvem:

 docker build -t myservice.azurecr.io/myservice . docker push myservice.azurecr.io/myservice 

Segredos, segredos ... Fornecemos acesso à imagem e salvamos as configurações.

Ao trabalhar com o AKS implantado, você precisa obter os créditos dele. Caso contrário, os comandos kubectl não serão executados. Para acessar o AKS, o seguinte comando é executado:

 az aks get-credentials --resource-group KubernetesGroup --name verycoolcluster 

Para acessar a imagem da janela de encaixe localizada no repositório da janela de encaixe em um contêiner particular, você precisa criar um segredo. Se você tiver uma imagem pública, poderá pular esta etapa.

Para criar um arquivo secreto, você deve executar um comando do seguinte formulário:

 kubectl create secret docker-registry regcred --docker-server=<your-registry-server> --docker-username=<your-name> --docker-password=<your-pword> --docker-email=<your-email> 

Se sua imagem estiver no repositório do docker, o valor de <your-registry-server> será https://index.docker.io/v1/

Para o Registro de Contêiner do Azure, o FQDN será <nome do registro> .azurecr.io

Ou seja, para criar um segredo para o contêiner no meu caso, eu fiz:

 kubectl create secret docker-registry regcred --docker-server="myservice.azurecr.io" --docker-username="myservice" --docker-password="PJSeyO9=lCMRDI7dGkz68wjhFGRGxSY3" --docker-email="asommer@yandex.ru" 

Agora você pode visualizar o conteúdo do arquivo secreto criado usando o comando:

 kubectl get secret regcred --output=yaml 

INFO

Se você usa o AKS, não pode criar um arquivo secreto, mas fornece acesso ao serviço ACR para o serviço AKS de outra maneira - executando um script especial. Você pode acessá-lo na seguinte página:

Autenticar com o Registro de Contêiner do Azure no Serviço Kubernetes do Azure

 #!/bin/bash AKS_RESOURCE_GROUP=KubernetesGroup AKS_CLUSTER_NAME=verycoolcluster ACR_RESOURCE_GROUP=MyACRGroup ACR_NAME=myservice # Get the id of the service principal configured for AKS CLIENT_ID=$(az aks show --resource-group $AKS_RESOURCE_GROUP --name $AKS_CLUSTER_NAME --query "servicePrincipalProfile.clientId" --output tsv) # Get the ACR registry resource id ACR_ID=$(az acr show --name $ACR_NAME --resource-group $ACR_RESOURCE_GROUP --query "id" --output tsv) # Create role assignment az role assignment create --assignee $CLIENT_ID --role Reader --scope $ACR_ID 

Você pode simplesmente modificar os valores das variáveis ​​AKS * e ACR *, copiar o script e colá-lo na CLI do Azure ou no Shell de Nuvem.

Kubernetes contém um armazenamento de credenciais seguro. Ou seja, você pode criar um arquivo com as configurações e o acesso a essas configurações a partir do exterior será difícil. Esse arquivo geralmente contém cadeias de conexão com o banco de dados e algum tipo de crédito. Se você não tiver essas informações no aplicativo (isso é verdade?), Poderá pular esta etapa.

Para criar um arquivo de configurações a partir da linha de comando, primeiro precisamos considerar o comando vi.

 vi < > 

criará um arquivo se ele estiver ausente ou abrir um existente

Para salvar as alterações inseridas, pressione ESC e depois ZZ

Para simplesmente sair sem salvar ESC e depois: q!

Uma descrição muito curta, mas deve ser suficiente. Posso acrescentar que a tecla Inserir pode ser muito útil.

Portanto, por meio do Azure Cloud Shell, crie um arquivo com um nome arbitrário (por exemplo, appsettings.json) e o conteúdo necessário. Vamos admitir isso:

 { "ConnectionString": "some secret string goes there" } 

E depois de executar o comando:

 kubectl create secret generic secret-appsettings --from-file=/home/youraccount/appsettings.json 

Este comando criará um segredo com configurações chamadas secret-appsettings
Você pode descobrir qual caminho substituir / home / youraccount pelo comando pwd

Criar implantação

As implantações são para serviços sem estado. Eles descrevem como os Pods e ReplicaSets serão criados e como serão atualizados. Pod é um grupo de contêineres (ou um único contêiner) que funcionam no mesmo ambiente. O objetivo do ReplicaSet é controlar que o número especificado de pods seja iniciado e funcione constantemente.
Com base no criado anteriormente, crio um arquivo deploy.yaml que criará três sub. O arquivo contém o seguinte código (lembro que os espaços no yaml são muito importantes):

 apiVersion: apps/v1beta1 kind: Deployment metadata: name: mydeployment spec: replicas: 3 minReadySeconds: 10 strategy: type: RollingUpdate rollingUpdate: maxUnavailable: 1 maxSurge: 1 template: metadata: labels: app: myapp spec: containers: - name: app image: myservice.azurecr.io/myservice:latest ports: - containerPort: 80 name: http protocol: TCP imagePullPolicy: Always env: - name: "ASPNETCORE_ENVIRONMENT" value: "Production" volumeMounts: - name: secrets mountPath: /app/secrets readOnly: true imagePullSecrets: - name: regcred volumes: - name: secrets secret: secretName: secret-appsettings 

Considere o código. O começo descreve o número de réplicas e a estratégia de atualização. Em seguida, a implantação recebe um nome (myapp) e uma referência à imagem do contêiner é indicada. As portas são registradas. 80 é a porta padrão para http. A seguir, estão as configurações do ambiente do ASP.NET Core. Em seguida, foram montados os créditos da imagem do docker privado e das configurações secretas do aplicativo que criamos recentemente.

  strategy: type: RollingUpdate rollingUpdate: maxUnavailable: 1 maxSurge: 1 

Esta peça é responsável pelo processo de atualização. maxSurge - o número de lareiras criadas além das existentes quando atualizadas (em unidades ou porcentagem). maxUnavailable - o número máximo de lares que podem ficar indisponíveis durante o processo de atualização.
A implantação pode ser criada usando o comando:

 kubectl apply -f deploy.yaml 

Conheça o Ingress

Para fornecer acesso aos serviços de cluster e organizar o balanceamento de carga, é usado um serviço chamado ingresso. Uma solução bastante popular é a entrada baseada no nginx. A maneira mais fácil de instalá-lo é usando o gerenciador de pacotes do Kubernetes chamado helm. A vantagem do Azure Cloud Shell é que o leme já está instalado nele. O que falta fazer para instalar o nginx-ingress. Digite:

 helm init 

Aguarde um pouco e execute:

 helm install stable/nginx-ingress --namespace kube-system --set rbac.create=false 

Criando certificados SSL com LetsEncrypt

Como o certificado SSL está vinculado a algum nome de domínio, definiremos nosso nome de recurso DNS.

Execute o seguinte comando e obtenha o IP externo

 kubectl get service -l app=nginx-ingress --namespace kube-system 

Substitua IP e o nome que inventamos para o subdomínio no script a seguir

 #!/bin/bash # Public IP address of your ingress controller IP="168.63.19.2" # Name to associate with public IP address DNSNAME="myservice-ingress" # Get the resource-id of the public ip PUBLICIPID=$(az network public-ip list --query "[?ipAddress!=null]|[?contains(ipAddress, '$IP')].[id]" --output tsv) # Update public ip address with DNS name az network public-ip update --ids $PUBLICIPID --dns-name $DNSNAME 

Simplesmente copiamos esse script, colamos na linha de comando e executamos dessa maneira. Como o nome do subdomínio, defino um nome muito "original" - myservice-ingress

Instale o gerenciador de certificados da mesma maneira, copiando e colando o seguinte script na linha de comandos. Aqui, mesmo nada de especial precisa ser mudado.

 helm install \ --name cert-manager \ --namespace kube-system \ stable/cert-manager \ --set ingressShim.defaultIssuerName=letsencrypt-prod \ --set ingressShim.defaultIssuerKind=ClusterIssuer \ --set rbac.create=false \ --set serviceAccount.create=false 

INFO

Se tivéssemos um cluster com RBAC, o script seria diferente.

 helm install stable/cert-manager --set ingressShim.defaultIssuerName=letsencrypt-staging --set ingressShim.defaultIssuerKind=ClusterIssuer 

Se o arquivo de certificado estiver disponível, você poderá adicioná-lo da seguinte forma:

 kubectl create secret tls tls-secret --cert CERT.crt --key KEY-FOR-CERT.key 

Mas como não temos um certificado de CA assinado, precisamos dançar um pouco com um pandeiro. Criaremos uma CA usando um serviço gratuito chamado LetsEncrypt . LetsEncrypt é uma autoridade de certificação que emite certificados gratuitamente. Uma organização tão altruísta, cujo objetivo é proteger a Internet.

Portanto, crie o arquivo cluster-issuer.yaml, que descreve a organização que emitiu o certificado.

 apiVersion: certmanager.k8s.io/v1alpha1 kind: ClusterIssuer metadata: name: letsencrypt-prod spec: acme: server: https://acme-v02.api.letsencrypt.org/directory email: youeemail@yourdomain.ru privateKeySecretRef: name: letsencrypt-prod http01: {} 

Você só precisa substituir o email pelo seu endereço e pode:

 kubectl apply -f cluster-issuer.yaml 

Em seguida, criamos o arquivo de certificado certificate.yaml, especificando o nome do ClusterIssuer criado e o domínio ao qual o certificado se destina - myservice-ingress.westeurope.cloudapp.azure.com

 apiVersion: certmanager.k8s.io/v1alpha1 kind: Certificate metadata: name: tls-prod-secret spec: secretName: tls-prod-secret dnsNames: - myservice-ingress.westeurope.cloudapp.azure.com acme: config: - http01: ingressClass: nginx domains: - myservice-ingress.westeurope.cloudapp.azure.com issuerRef: name: letsencrypt-prod kind: ClusterIssuer 

Realizamos:

 kubectl apply -f certificate.yaml 

Criação de Serviço e Ingresso

O Kubernetes pode criar quatro tipos diferentes de serviços.
O serviço padrão é ClusterIP. O acesso a esse serviço é possível apenas a partir do cluster via IP interno.

O NodePort cria automaticamente o serviço ClusterIP. O acesso ao NodePort é possível externamente pela seguinte rota:

O balanceador de carga LoadBalancer fornece acesso ao serviço de fora, criando automaticamente os serviços NodePort e ClusterIP.

ExternalName associa o serviço a um nome externo.

O serviço básico é suficiente para nós:

 apiVersion: v1 kind: Service metadata: name: myservice spec: type: ClusterIP ports: - port: 80 name: http targetPort: http selector: app: myapp 

Com o valor do seletor, indicamos o nome da nossa implantação.
Resta criar um serviço

 kubectl apply -f service.yaml 

E, como etapa final, criamos uma entrada com a qual eu já o apresentei um pouco mais alto neste artigo. No yaml, especificaremos o nome do emissor do cluster e o certificado. Nós os criamos anteriormente.

 apiVersion: extensions/v1beta1 kind: Ingress metadata: name: myingress annotations: kubernetes.io/ingress.class: nginx certmanager.k8s.io/cluster-issuer: letsencrypt-prod nginx.ingress.kubernetes.io/rewrite-target: / spec: tls: - hosts: - myservice-ingress.westeurope.cloudapp.azure.com secretName: tls-prod-secret rules: - host: myservice-ingress.westeurope.cloudapp.azure.com http: paths: - path: / backend: serviceName: myservice servicePort: 80 

Algum tempo depois de criar a entrada usando o mesmo comando kubectl apply, nosso microsserviço deve ficar disponível em https: // myservice-ingress.westeurope.cloudapp.azure.com . Ao clicar no cadeado na barra de endereços do navegador ao lado de https, você pode verificar se o certificado é válido e emitido pela CA.

Lembramos que esta é a versão completa de um artigo da revista Hacker . Seu autor é Alexey Sommer .