10 de out. de 2024

Protegendo o recurso de gateway de entrada do K8s com o plug-in do ATLAS Certificate Manager

O que é entrada?

A entrada expõe rotas HTTP e HTTPS de fora do cluster para serviços dentro do cluster. O roteamento de tráfego é controlado por regras definidas no recurso de entrada.

Aqui está um exemplo simples em que um Ingress envia todo o seu tráfego para um serviço:

Pré-requisitos:

1. Descompacte $sudo apt install descompacte
2. AWS CLI
3. $curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"|
   
   descompacte awscliv2.zip
   sudo ./aws/install
4. Crie um bucket do S3.
5. Crie uma zona hospedada no Route 53. (O nome da zona é o mesmo que o nome do bucket ou deve ser o sucessor do nome do bucket. Por exemplo, se o nome do bucket for example.com, o nome da zona hospedada deverá ser abc.example.com.)
6. Instalação do Helm a partir do script.
   
   $curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
   $chmod 700 get_helm.sh
   $./get_helm.sh

Há algumas políticas necessárias para executar o cluster com êxito, que devem ser atribuídas a um usuário e a uma função para o cluster:

#IAM URL: https://console.aws.amazon.com/iamv2/home#/home

#Create um usuário para o cluster K8S e atribua as políticas abaixo:

1. Vá para Usuários.
2. Em seguida, adicione usuários.
3. Dê um nome ao usuário.
4. Selecione a chave de acesso: Acesso programático
5. Permissões
6. Selecione Anexar políticas existentes diretamente e selecione as políticas abaixo para este usuário.

              a) Acesso total à VPC

              b) Acesso total ao EC2

              c) Acesso total S3

              d) Acesso total à Route53

              e) Acesso total ao IAM

#Create uma função para o cluster K8S e atribua as políticas abaixo:

1. Acesse o painel do IAM https://console.aws.amazon.com/iamv2/home#/home
    
2. Papéis
3. Criar função
4. Forme o caso de uso comum, selecione EC2 e vá para a próxima tela para obter permissões.
5. Selecione as permissões abaixo para este usuário

              a) Acesso total à VPC

              b) Acesso total ao EC2

              c) Acesso total S3

              d) Acesso total à Route53

              e) Acesso total ao IAM

#Launch uma instância Ec2 e atribua essa função à instância.

Instalando kubectl e kops

kubectl:

#Download a versão mais recente com o comando:

$curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

#make o executável do arquivo baixado

$chmod +x kubectl

#Move o executável para o /usr/local/bin

$sudo mv kubectl /usr/local/bin

kops:

#Download a versão mais recente com o comando:

$curl -LO https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64

#Make o executável binário

$chmod +x kops-linux-amd64

#Move o executável para /usr/local/bin

$sudo mv kops-linux-amd64 /usr/local/bin/kops

Para trabalhar mais, é necessário fazer login com o usuário programático criado acima

$aws configure

#enter o ID da chave de acesso e a chave de acesso secreta.

#Provide os detalhes da região, ou seja, US-East-1 ou qualquer outro

#Give formato de saída como "json".

#Create um bucket do S3 por meio do console do bucket do S3: https://s3.console.aws.amazon.com/s3/home?region=us-east-1

#Create uma zona hospedada privada no console do Route53: https://console.aws.amazon.com/route53/v2/home#Dashboard

#Generate chaves públicas e privadas.

$ssh-keygen

#Everything está configurado. Agora vamos começar a criar o cluster com os comandos abaixo.

$export KOPS_STATE_STORE="s3://pki.atlasqa.co.uk"
$export MASTER_SIZE=${MASTER_SIZE:-m4.large}
$export NODE_SIZE=${NODE_SIZE:-m4.large}
$export ZONES="us-east-1a,us-east-1b,us-east-1c"

$kops criar cluster pki.atlasqa.co.uk --node-count 3 --zones $ZONES --node-size $NODE_SIZE --master-size $MASTER_SIZE --master-zones $ZONES --dns public --dns-zone pki.atlasqa.co.uk --cloud aws

#It descreverá tudo o que ele criará dentro do cluster. Na próxima etapa, o kops atualizará o cluster e os recursos serão criados.

$kops cluster de atualização --name pki.atlasqa.co.uk --yes --admin

#It levará cerca de 20 minutos para preparar todos os recursos no cluster.

#Check o status do cluster após 20 minutos com o comando abaixo.

$kops validar cluster --name pki.atlasqa.co.uk

 

O cluster está configurado; Há 3 máquinas de nó em execução na região US-East-1 e 3 master em execução em US-East-1 de acordo com as zonas de disponibilidade.

• Instalar cert-manager

#Add o repositório do Jetstack Helm.

$helm repositório add jetstack https://charts.jetstack.io

#Update o cache local do repositório de gráficos do Helm.

$helm atualização do repositório

#Install os recursos CustomResourceDefinition separadamente.

$kubectl aplicar -f https://github.com/cert-manager/cert-manager/releases/download/v1.8.0/cert-manager.crds.yaml

#Install o cert-manager usando o helm.

$helm instalar cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --version v1.8.0

#Next, instale o controlador Atlas e os CRDs:'

$kubectl aplicar -f https://github.com/globalsign/atlas-cert-manager/releases/download/v0.0.1/install.yaml

O controlador está implantado e pronto para lidar com solicitações do Atlas.

#Label o namespace cert-manager para desabilitar a validação de recursos.

$kubectl namespace de rótulo cert-manager certmanager.k8s.io/disable-validation=true

• Instale o Nginx-ingress-controller no namespace cert-manager e crie um registro para sua zona DNS.

$helm upgrade --install ingress-nginx ingress-nginx --repo https://kubernetes.github.io/ingress-nginx --namespace cert-manager

• Adicione um registro A à sua zona DNS.

$kubectl get svc -n cert-manager

Passo 1. Configure a conta do ATLAS como um segredo no Kubernetes.

Crie um segredo para armazenar a conta do ATLAS api_key, segredos junto com o mTLS e a chave privada:

kubectl criar segredo credenciais genéricas do emissor --from-literal=apikey=$API_KEY --from-literal=apisecret=$API_SECRET --from-literal=cert="$(cat mTLS.pem)" --from-literal=certkey="$(cat privatekey.pem)" -n cert-manager

Etapa 2. Configure o GlobalSign como o emissor/ClusterIssuer.

$kubectl apply -f issuer.yaml

issuer.yaml
apiVersion: hvca.globalsign.com/v1alpha1
kind: Issuer
metadata:
  name: gs-issuer
  namespace: cert-manager
spec:
  authSecretName: "issuer-credentials"
  url: "https://emea.api.hvca.globalsign.com:8443/v2"

Etapa 3. Crie um recurso de certificado.

$kubectl apply -f cert.yaml

cert.yaml
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: pki.atlasqa.co.uk
  namespace: cert-manager
spec:
   # Nomes secretos são sempre necessários.
  secretName: www.atlasqa.co.uk
 
  duration: 2160h # 90d
  renewBefore: 360h # 15d
  subject:
  #  organizations:
  #    - jetstack
  # O uso do campo de nome comum foi descontinuado desde 2000 e é
  # desencorajado de ser usado.
  commonName: pki.atlasqa.co.uk
  isCA: false
  privateKey:
    algorithm: RSA
    encoding: PKCS1
    size: 2048
  usages:
    - server auth
    #- client auth
  # É necessário pelo menos um nome DNS, URI ou endereço IP.
#  dnsNames:
#    -
#www.atlasqa.co.uk
  # As referências do emissor são sempre necessárias.
  issuerRef:
    name: gs-issuer
    # Podemos fazer referência a ClusterIssuers alterando o tipo aqui.   
    # O valor padrão é do tipo Emissor (ou seja, um Emissor com namespace local): Emissor
    # Isso é opcional, pois cert-manager usará esse valor como padrão, no entanto
    # se você estiver usando um emissor externo, altere-o para esse grupo de emissores.
    group: hvca.globalsign.com

Step 4. Securing ingress resource.

$kubectl apply -f ingress.yaml

ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx
  namespace: cert-manager
  annotations:
    cert-manager.io/issuer: GS-issuer
    kubernetes.io/ingress.class: nginx
spec:
  tls:
    - hosts:
        - pki.atlasqa.co.uk
      secretName: www.atlasqa.co.uk
  rules:
    - host: pki.atlasqa.co.uk
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: example-service
                port:
                  number: 80