Instalando vários controladores do Snyk em um único cluster Kubernetes

O Kubernetes oferece uma interface para executar sistemas distribuídos com facilidade. Ele cuida do escalonamento e da recuperação de falhas dos seus aplicativos, oferece padrões de implantação e muito mais. Em relação à segurança, cabe às equipes que implantam workloads no cluster Kubernetes decidir quais deles devem ser monitorados para atender aos requisitos de segurança dos aplicativos.

Mas e se cada equipe pudesse controlar quais imagens de contêiner são verificadas e quais workloads específicos são monitorados? Várias equipes podem implantar workloads no Kubernetes, cada uma com requisitos próprios sobre o que deve ser monitorado. A melhor maneira de atender a esse caso de uso é permitir que cada equipe configure sua própria integração do Snyk com o Kubernetes e monitore os workloads necessários. Veja como isso funciona.

Visão geral da integração do Snyk com o Kubernetes

O Snyk se integra ao Kubernetes, permitindo que você importe e teste continuamente seus workloads em execução para identificar vulnerabilidades nas imagens subjacentes e configurações que possam reduzir a segurança desses workloads. Depois da implantação, o Snyk continua monitorando os workloads para identificar exposição a vulnerabilidades recém-descobertas e outros problemas de segurança quando novos contêineres são implantados ou a configuração do workload muda.

Diagrama da arquitetura da integração com o Kubernetes

Como instalar vários controladores do Snyk em um único cluster Kubernetes

Agora vem a parte divertida! Vamos explicar passo a passo como configurar vários controladores do Snyk em um único cluster Kubernetes. Estas são as etapas:

1. Configure namespaces separados

2. Crie uma organização do Snyk para cada namespace

3. Instale e configure snyk monitor para o primeiro namespace (apples)

4. Instale e configure snyk monitor para o segundo namespace (bananas)

5. Verifique se os workloads implantados são importados automaticamente pela política

6. Implante workloads em bananas para importá-los automaticamente por meio de um arquivo de política Rego

Pré-requisitos

1. Para usar a integração com o Kubernetes, você precisa ter uma conta Business ou Enterprise do Snyk. Se ainda não tiver uma dessas contas, você pode iniciar uma avaliação gratuita do nosso plano Business. Mesmo que não queira testar por conta própria, recomendo que continue lendo (pulando os blocos de código) para aprender a instalar e gerenciar vários controladores do Snyk em um único cluster Kubernetes.

2. Um cluster Kubernetes, como AKS, EKS, GKE, Red Hat OpenShift ou qualquer outra distribuição compatível.

Etapa 1: configure namespaces separados

Nesta demonstração, estou usando um serviço Azure AKS como cluster Kubernetes. Nesse cluster, vamos instalar dois controladores do Snyk, cada um em seu próprio namespace: um no namespace apples e outro no namespace bananas, como mostra o diagrama abaixo.

Crie os namespaces conforme mostrado abaixo:

1➜  kubectl create namespace apples
2namespace/apples created
3➜  kubectl create namespace bananas
4namespace/bananas created

Etapa 2: crie uma organização do Snyk para cada namespace

Usar organizações do Snyk separadas nos permite separar a verificação de workloads. Assim, as equipes de produto podem usar suas próprias organizações para ter mais controle sobre a verificação de seus workloads e imagens. Você também pode usar a mesma organização com cada um dos controladores do Snyk que vamos implantar, mas, neste caso, vamos mantê-las separadas. Em ambos os casos, os workloads aparecerão com um rótulo definido durante a instalação dos controladores do Snyk.

Nossas novas organizações

Uma para o namespace apples:

Uma para o namespace bananas:

Depois de criadas, você verá duas organizações vazias no aplicativo do Snyk. Vamos usá-las em breve.

Em cada organização, habilite a integração com o Kubernetes: selecione a guia Integrações, escolha Kubernetes e clique em Conectar. Em seguida, consulte a documentação do Snyk para Kubernetes para concluir a configuração.

Anote os IDs de integração da integração do Kubernetes de cada organização do Snyk: você precisará deles em breve. Para encontrar o ID de integração do Kubernetes, clique no ícone de configurações da organização na barra de navegação superior do Snyk, acesse Integrações na barra lateral e selecione a integração com o Kubernetes, como mostrado abaixo.

Etapa 3: instale e configure snyk monitor para o namespace apples

Agora que configuramos nossas organizações e integrações e as conectamos ao cluster, podemos configurar o Snyk Monitor em uma janela do terminal.

Vamos criar um arquivo para assinar eventos de workload, definir os critérios das assinaturas, instalar o gráfico Helm do Snyk para monitoramento do Kubernetes e configurar/iniciar o monitor.

Crie o arquivo do registro

No terminal, crie um diretório para a organização apples e acesse-o:

1➜  mkdir apples
2➜  cd apples

Crie um arquivo chamado workload-events.rego com o conteúdo abaixo, substituindo <APPLES_INTEGRATION_ID> pelo ID de integração da integração do Kubernetes da organização apples.

Com a política Rego abaixo, estamos instruindo o controlador do Snyk a importar/excluir workloads somente do namespace apples, desde que o tipo de workload do Kubernetes não seja CronJob nem Service. Para saber mais sobre os diferentes tipos de workload, consulte a documentação do Snyk.

workload-events.rego

1package snyk
2orgs := ["<APPLES_INTEGRATION_ID>"]
3default workload_events = false
4workload_events {
5  input.metadata.namespace == "apples"
6  input.kind != "CronJob"
7  input.kind != "Service"
8}

Adicione os gráficos Helm do Snyk ao seu repositório

Acesse seu ambiente Kubernetes e execute o comando a seguir para adicionar o repositório Snyk Charts ao Helm. Vamos precisar dele em breve, ao instalar este gráfico Helm.

1➜  helm repo add snyk-charts https://snyk.github.io/kubernetes-monitor --force-update
2"snyk-charts" has been added to your repositories

Crie a configuração do Snyk Monitor e implante o gráfico Helm

Com um secret do Kubernetes, podemos executar o processo sem expor credenciais em texto simples. Nestas etapas, vamos criar e usar o secret para implantar a configuração da organização apples.

Crie o secret snyk-monitor para o namespace apples, substituindo <APPLES_INTEGRATION_ID> pelo ID da integração do Kubernetes da organização apples no aplicativo do Snyk. Nesta demonstração, usamos o Docker Hub público como registro de contêineres, que não exige credenciais para acessar imagens públicas. Para saber mais sobre como usar registros privados de contêineres, consulte a documentação do controlador do Snyk.

1➜ kubectl create secret generic snyk-monitor -n apples \
2    --from-literal=dockercfg.json={} \
3    --from-literal=integrationId=<APPLES_INTEGRATION_ID>
4secret/snyk-monitor created

Agora, crie um configmap para armazenar o arquivo de política Rego que o snyk-monitor usará para determinar o que importar ou excluir automaticamente do namespace apples:

1➜ kubectl create configmap snyk-monitor-custom-policies -n apples \       --from-file=./workload-events.rego
2configmap/snyk-monitor-custom-policies created

Em seguida, instale o snyk-monitor no namespace apples, substituindo <APPLES_INTEGRATION_ID> pelo ID de integração do Snyk da organização apples no comando:

1➜ helm upgrade --install snyk-monitor-apples snyk-charts/snyk-monitor \
2        --namespace apples \
3        --set clusterName="AKS K8s - Apples" \
4        --set policyOrgs=<APPLES_INTEGRATION_ID> \
5        --set workloadPoliciesMap=snyk-monitor-custom-policies
6
7Release "snyk-monitor-apples" does not exist. Installing it now.
8LAST DEPLOYED: Thu Jul 14 19:29:28 2022
9NAMESPACE: apples
10STATUS: deployed
11REVISION: 1
12TEST SUITE: None

Observação: O rótulo “AKS K8s - Apples” permite encontrar no Snyk os workloads importados, que você verá em breve.

Por fim, verifique se tudo está funcionando (este comando pressupõe que você tenha instalado o jq; se não tiver, remova o trecho | jq do comando):

1➜ helm ls -A -o json | jq
2[
3  {
4"name": "snyk-monitor-apples",
5"namespace": "apples",
6"revision": "1",
7"updated": "2022-07-14 19:45:56.681028 +1000 AEST",
8"status": "deployed",
9"chart": "snyk-monitor-1.92.10",
10"app_version": ""
11  }
12]
13
14➜ kubectl get pods -n apples
15NAME                             READY   STATUS RESTARTS   AGE
16snyk-monitor-apples-797cd64c-sqvj4   1/1 Running   0      16m

Neste momento, temos um controlador do Snyk instalado no namespace apples com um nome exclusivo. Mais adiante, mostraremos como esse controlador importa automaticamente os workloads de acordo com a configuração, à medida que eles são implantados no namespace apples do cluster Kubernetes. Por enquanto, você pode notar que, ao atualizar a página de projetos da organização apples, ela já verificou o próprio Snyk Monitor. Isso acontece porque pedimos que verificasse os workloads do tipo Deployment no namespace apples.

Etapa 4: instale e configure snyk monitor para o namespace bananas

Crie um diretório chamado bananas e acesse-o:

1➜ cd ..
2➜ mkdir bananas
3➜ cd bananas

Agora, crie um arquivo chamado workload-events.rego com o conteúdo abaixo e substitua <BANANAS_INTEGRATION_ID> pelo ID da integração do Kubernetes da organização bananas no aplicativo do Snyk:

1package snyk
2orgs := ["<BANANAS_INTEGRATION_ID>"]
3default workload_events = false
4workload_events {
5      input.metadata.namespace == "bananas"
6      input.kind != "CronJob"
7      input.kind != "Service"
8}

Em seguida, crie o secret snyk-monitor para o namespace bananas, substituindo BANANAS_INTEGRATION_ID pelo ID da integração do Kubernetes da organização bananas no aplicativo do Snyk:

1➜  ~/snyk/SE/blogs/snyk-multi-namespace-controllers/bananas kubectl create secret generic snyk-monitor -n bananas \
2  --from-literal=dockercfg.json={} \
3  --from-literal=integrationId=BANANAS_INTEGRATION_ID
4secret/snyk-monitor created

Depois, crie um configmap para armazenar o arquivo de política Rego que o snyk-monitor usará para determinar o que importar ou excluir automaticamente do namespace bananas:

1➜ kubectl create configmap snyk-monitor-custom-policies -n bananas --from-file=./workload-events.rego
2configmap/snyk-monitor-custom-policies created

Instale o snyk-monitor no namespace bananas, substituindo ‰¤BANANAS_INTEGRATION_ID> pelo ID da integração do Kubernetes da organização bananas no aplicativo do Snyk:

1➜ helm upgrade --install snyk-monitor-bananas snyk-charts/snyk-monitor \
2      --namespace bananas \
3      --set clusterName="K8s - Bananas" \
4      --set policyOrgs=<BANANAS_INTEGRATION_ID> \
5      --set workloadPoliciesMap=snyk-monitor-custom-policies
6Release "snyk-monitor-bananas" does not exist. Installing it now.
7NAME: snyk-monitor-bananas
8LAST DEPLOYED: Thu Jul 14 20:19:36 2022
9NAMESPACE: bananas
10STATUS: deployed
11REVISION: 1
12TEST SUITE: None

Por fim, verifique se tudo está funcionando:

1➜ helm ls -A -o json | jq .
2[
3  {
4"name": "snyk-monitor-apples",
5"namespace": "apples",
6"revision": "1",
7"updated": "2022-07-14 19:45:56.681028 +1000 AEST",
8"status": "deployed",
9"chart": "snyk-monitor-1.92.10",
10"app_version": ""
11  },
12  {
13"name": "snyk-monitor-bananas",
14"namespace": "bananas",
15"revision": "1",
16"updated": "2022-07-14 20:19:36.563328 +1000 AEST",
17"status": "deployed",
18"chart": "snyk-monitor-1.92.10",
19"app_version": ""
20  }
21]
22
23➜ kubectl get pods -n bananas
24NAME                                  READY   STATUS   RESTARTS  AGE
25Snyk-monitor-bananas-54b8c4bf89-r6tf2   1/1 Running   0      3m38s

Etapa 5: verifique se os workloads implantados são importados automaticamente pela política

Em seguida, vamos implantar workloads no namespace apples para confirmar que eles são importados automaticamente. Vamos começar com um aplicativo Spring Boot, que implantaremos no Kubernetes conforme mostrado abaixo.

Crie um arquivo chamado springbootemployee-K8s.yaml com o seguinte conteúdo:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: springboot-employee-api-apples
5  namespace: apples
6spec:
7  selector:
8matchLabels:
9  app: springboot-employee-api-apples
10  replicas: 1
11  template:
12metadata:
13  labels:
14    app: springboot-employee-api-apples
15spec:
16  containers:
17    - name: springboot-employee-api-apples
18      image: pasapples/springbootemployee:multi-stage-add-layers
19      imagePullPolicy: Always
20      ports:
21        - containerPort: 8080

Depois, implante-o:

1➜ kubectl apply -f springbootemployee-K8s.yaml
2deployment.apps/springboot-employee-api-apples created

Após alguns minutos, verifique se o workload foi verificado e importado automaticamente para a organização apples no aplicativo do Snyk, conforme instruído pelo controlador do Snyk no namespace apples.

Etapa 6: implante workloads em bananas — importação automática por meio de um arquivo de política Rego

Crie um arquivo chamado snyk-boot-web-deployment.yaml com o seguinte conteúdo:

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4  name: snyk-boot-web
5  namespace: bananas
6spec:
7  selector:
8    matchLabels:
9      app: snyk-boot-web
10  replicas: 1
11  template:
12    metadata:
13      labels:
14        app: snyk-boot-web
15    spec:
16      containers:
17        - name: snyk-boot-web
18          image: pasapples/snyk-boot-web:v1
19          imagePullPolicy: Always
20          ports:
21            - containerPort: 5000

Implante-o assim:

1➜ kubectl apply -f snyk-boot-web-deployment.yaml
2deployment.apps/snyk-boot-web created

Após cerca de 3 minutos, verifique se o workload foi verificado e importado automaticamente para a organização bananas no aplicativo do Snyk, conforme instruído pelo controlador do Snyk no namespace bananas.

Bônus: como visualizar os logs dos controladores do Snyk

As configurações e os arquivos YAML do Kubernetes podem ser um pouco complicados. Se você tiver problemas para configurar os monitores, pode ser útil visualizar os logs de cada controlador do Snyk, usando os comandos a seguir:

Controlador do Snyk de Apples

1export APPLES_POD=`kubectl get pods --namespace apples -l "app.kubernetes.io/name=snyk-monitor-apples" -o jsonpath="{.items[0].metadata.name}"`
2
3kubectl logs -n apples $APPLES_POD -f

Controlador do Snyk de Bananas

1export BANANAS_POD=`kubectl get pods --namespace bananas -l "app.kubernetes.io/name=snyk-monitor-bananas" -o jsonpath="{.items[0].metadata.name}"`
2
3kubectl logs -n bananas $BANANAS_POD -f

Resumo

Neste blog, mostramos como implantar vários controladores do Snyk em um único cluster Kubernetes, cada um monitorando seu próprio namespace. Os controladores se comunicam com a API do Kubernetes para determinar quais workloads (como Deployment, ReplicationController e CronJob, conforme definidos no arquivo de política Rego) estão em execução no cluster, localizar as imagens associadas e verificá-las diretamente no cluster em busca de vulnerabilidades.

Sinta-se à vontade para testar estas etapas no seu próprio cluster Kubernetes. Para isso, inicie uma avaliação gratuita do plano Snyk Business.

Recursos para saber mais

Agora que você aprendeu como é fácil configurar a integração do Snyk com o Kubernetes, confira alguns links úteis para começar sua jornada de segurança de contêineres.

• Segurança de contêineres e Kubernetes com o Snyk

• Visão geral da integração com o Kubernetes

• Como configurar o Snyk Container para importar/excluir automaticamente projetos de workloads do Kubernetes

• Aprenda Rego com o excelente curso tutorial da Styra