Como usar o Pulumi para automatizar a integração do Snyk Kubernetes para contêineres

Todos já ouvimos falar do termo infraestrutura como código (IaC), mas código, nesse contexto, não é exatamente código no sentido de uma linguagem de programação. IaC geralmente se refere à configuração da infraestrutura por meio de ferramentas como Terraform, CloudFormation, YAML do Kubernetes ou modelos do Azure Resource Manager — que, na prática, definem como a infraestrutura será criada. Essas configurações não oferecem a flexibilidade e o poder de uma linguagem de programação moderna. Portanto, IaC é código, mas geralmente não é esse tipo de código.

Nesta postagem, vamos mostrar como usar o Pulumi, uma nova ferramenta de código aberto que permite aos desenvolvedores escrever código em várias linguagens, como JavaScript, TypeScript, Python e Go, para criar tudo o que é necessário para configurar a integração do Kubernetes no Snyk Container.

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

A Snyk se integra ao Kubernetes, permitindo que você importe e teste suas cargas de trabalho em execução e identifique vulnerabilidades nas imagens e configurações associadas que possam comprometer a segurança dessas cargas. Após a importação, a Snyk continua monitorando essas cargas de trabalho e identificando novos problemas de segurança à medida que novas imagens são implantadas e a configuração muda.

O que é Pulumi?

Pulumi é uma ferramenta de IaC de código aberto que usa as linguagens de programação mais populares para simplificar o provisionamento e o gerenciamento de recursos na nuvem.

Fundada em 2017, a Pulumi mudou profundamente a forma como as equipes de DevOps abordam o conceito de infraestrutura como código. Em vez de depender de linguagens específicas de domínio, a Pulumi permite que as organizações usem linguagens de programação de verdade para provisionar e desativar infraestrutura nativa da nuvem.

O Pulumi oferece suporte às seguintes linguagens de programação:

• Python

• JavaScript

• Go

• TypeScript

• Linguagens .NET (C#, F# e VB)

Como instalar a integração do Snyk com Kubernetes usando o Pulumi

Agora vem a parte divertida! Vamos configurar o Pulumi passo a passo e iniciar nossas automações. Estas são as etapas:

1. Crie um ID de integração com Kubernetes no app da Snyk

2. Clone o repositório de exemplo

3. Faça a autenticação no Google Cloud

4. Crie uma nova stack do Pulumi

5. Defina as variáveis de configuração necessárias do Pulumi

6. Implante tudo com pulumi up

7. Recupere a configuração do Kubernetes

8. Destrua toda a configuração

Pré-requisitos

1. Para usar a integração com Kubernetes, você precisa ter uma conta Business ou Enterprise da Snyk. Se ainda não tiver uma, você pode se inscrever para um teste gratuito de 14 dias do plano Business.

2. Vamos implantar no Google Cloud, então você precisará de uma conta. Se ainda não tiver uma, inscreva-se gratuitamente aqui. Em ambos os casos, siga estas instruções para conectar o Pulumi à sua conta do Google Cloud.

3. Este exemplo pressupõe que a CLI gcloud esteja no seu PATH. Ela é instalada como parte do Google Cloud SDK.

4. Verifique se você tem o Python 3, uma conta do Pulumi e a CLI do Pulumi.

5. Observe que o Pulumi exige que o Python 3 seja a versão padrão no seu ambiente. Se você tiver o Python 2 e o Python 3 instalados, talvez seja necessário criar um alias. Para verificar, execute o comando a seguir e confirme que está usando a versão mais recente do 3.x:

1❯ python --version
2Python 3.9.9

Etapa 1: Crie um ID de integração com Kubernetes no app da Snyk

Entre na Snyk e selecione a organização em que deseja configurar automaticamente a integração com Kubernetes. Pode ser uma organização vazia ou uma já existente com projetos. Neste exemplo, verifique se a integração com Kubernetes ainda não está configurada na organização escolhida.

Em seguida, clique em Integrações > Kubernetes > Conectar. Se você não tiver uma conta Business ou Enterprise da Snyk, não poderá concluir esta etapa.

Anote o ID da integração, pois vamos precisar dele em breve.

Pronto! Agora você pode configurar a demonstração da integração do Snyk com Kubernetes usando infraestrutura como código com o Pulumi. O Pulumi fará o seguinte:

• Criar um cluster GKE

• Implantar o controlador da Snyk no cluster0

• Configurar a integração do Snyk com Kubernetes para importar automaticamente as cargas de trabalho do K8s para a Snyk

• Implantar uma carga de trabalho de exemplo no namespace apples, de acordo com nosso arquivo de política Rego

Etapa 2: Clone o repositório de exemplo

Clone o repositório de demonstração no GitHub a seguir, como mostrado abaixo:

1$ git clone https://github.com/papicella/snyk-kubernetes-integration
2Cloning into 'snyk-kubernetes-integration'...
3remote: Enumerating objects: 18, done.
4remote: Counting objects: 100% (18/18), done.
5remote: Compressing objects: 100% (14/14), done.
6remote: Total 18 (delta 8), reused 14 (delta 4), pack-reused 0
7Receiving objects: 100% (18/18), 8.76 KiB | 4.38 MiB/s, done.
8Resolving deltas: 100% (8/8), done.

Depois de clonar o repositório, acesse-o com cd e execute os próximos comandos…

Etapa 3: Faça a autenticação no Google Cloud

Para implantar esta demonstração, autentique-se no Google Cloud usando a autenticação local. Há outras maneiras de configurar o Pulumi com o Google Cloud, mas esta é a mais simples para a demonstração:

1$ gcloud auth login

Etapa 4: Crie uma nova stack do Pulumi

Crie uma nova stack, que será um destino de implantação isolado para este exemplo. Use dev como exemplo:

1$ pulumi stack init dev

Etapa 5: Defina as variáveis de configuração necessárias do Pulumi

Em muitos casos, stacks diferentes de um mesmo projeto precisam de valores distintos. Por exemplo, talvez você queira usar um tamanho diferente para sua instância do Google Cloud ou uma quantidade diferente de servidores no cluster do Kubernetes nas stacks de desenvolvimento e produção.

Os pares de chave e valor de cada stack ficam armazenados no arquivo de configurações da stack do seu projeto, cujo nome padrão é Pulumi.<stack-name>.yaml. Em geral, você pode ignorar esse arquivo, embora seja possível adicioná-lo ao controle de versão junto com o código-fonte do projeto.

Adicione as seguintes variáveis de configuração à nossa stack, como mostrado abaixo:

1$ pulumi config set gcp:project [your-gcp-project-here] # Eg: snyk-cx-se-demo
2$ pulumi config set gcp:zone us-central1-c # any valid GCP zone here
3$ pulumi config set password --secret [your-cluster-password-here] # password for the cluster
4$ pulumi config set master_version 1.21.6-gke.1500 # any valid K8s master version on GKE

Por padrão, seu cluster terá 3 nós do tipo n1-standard-1. Essa configuração pode ser alterada. Para escolher 5 nós do tipo n1-standard-2, por exemplo, você pode executar estes comandos:

1$ pulumi config set node_count 5
2$ pulumi config set node_machine_type n1-standard-2

Por fim, precisamos configurar as definições necessárias da integração do Snyk com Kubernetes, que serão usadas para adicionar automaticamente essa integração ao nosso cluster. Precisamos do ID da integração com Kubernetes e do ID da organização da Snyk. Neste exemplo, eles são iguais:

1$ pulumi config set snyk_K8s_integration_id K8S_INTEGRATION_ID #same as ORG_ID at the moment
2$ pulumi config set snyk_org_id ORG_ID # your Snyk ORG ID under settings

Isso mostra como você pode configurar stacks de maneiras úteis. Você pode até alterar essas configurações depois do provisionamento.

Depois de concluir esta etapa, você terá um arquivo Pulumi.dev.yaml com o seguinte conteúdo:

1config:
2gcp-K8s-integration-demo:master_version: 1.21.5-gke.1302
3gcp-K8s-integration-demo:node_count: "3"
4gcp-K8s-integration-demo:node_machine_type: n1-standard-2
5gcp-K8s-integration-demo:password:
6    secure: AAABsomesecret+EnF1p4w==
7gcp-K8s-integration-demo:snyk_K8s_integration_id: yyyy1234
8gcp-K8s-integration-demo:snyk_org_id: yyyy1234
9gcp:project: snyk-cx-se-demo
10gcp:zone: us-central1-c

Etapa 6: Implante tudo com pulumi up

A implantação de tudo com o comando pulumi up provisiona todos os recursos do Google Cloud necessários para a integração do Kubernetes com a Snyk, incluindo o próprio cluster GKE e o gráfico Helm do controlador da Snyk. Em seguida, implanta um deployment do Kubernetes que executa uma aplicação Spring Boot:

1$ pulumi up

Será exibida uma prévia, você precisará confirmar e, em seguida, começará o provisionamento da demonstração da integração do Snyk com Kubernetes:

1$ pulumi up
2Previewing update (dev)
3
4View Live: https://app.pulumi.com/papicella/gcp-K8s-integration-demo/dev/previews/1db6492c-ae23-4e87-abf0-41e09fb62177
5
6    Type                                                              Name                          Plan
7+   pulumi:pulumi:Stack                                               gcp-K8s-integration-demo-dev  create
8+   ├─ kubernetes:helm.sh/v3:Chart                                    snyk-monitor                  create
9+   │  ├─ kubernetes:core/v1:ServiceAccount                           snyk-monitor/snyk-monitor     create
10+   │  ├─ kubernetes:networking.k8s.io/v1:NetworkPolicy               snyk-monitor/snyk-monitor     create
11+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRole         snyk-monitor                  create
12+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRoleBinding  snyk-monitor                  create
13+   │  └─ kubernetes:apps/v1:Deployment                               snyk-monitor/snyk-monitor     create
14+   ├─ gcp:container:Cluster                                          pulumi-gke-cluster            create
15+   ├─ pulumi:providers:kubernetes                                    gke_k8s                       create
16+   ├─ kubernetes:core/v1:Namespace                                   snyk-monitor                  create
17+   ├─ kubernetes:core/v1:Namespace                                   apples                        create
18+   ├─ kubernetes:core/v1:ConfigMap                                   snyk-monitor-custom-policies  create
19+   ├─ kubernetes:core/v1:Service                                     springboot-employee-api       create
20+   ├─ kubernetes:core/v1:Secret                                      snyk-monitor                  create
21+   └─ kubernetes:apps/v1:Deployment                                  springboot-employee-api       create
22
23Resources:
24    + 15 to create

Após cerca de cinco minutos, seu cluster estará pronto, com o controlador da Snyk instalado e uma carga de trabalho de exemplo importada automaticamente para sua organização da Snyk:

1Do you want to perform this update? yes
2Updating (dev)
3
4View Live: https://app.pulumi.com/papicella/gcp-K8s-integration-demo/dev/updates/1
5
6    Type                                                              Name                          Status
7+   pulumi:pulumi:Stack                                               gcp-K8s-integration-demo-dev  created
8+   ├─ kubernetes:helm.sh/v3:Chart                                    snyk-monitor                  created
9+   │  ├─ kubernetes:core/v1:ServiceAccount                           snyk-monitor/snyk-monitor     created
10+   │  ├─ kubernetes:networking.k8s.io/v1:NetworkPolicy               snyk-monitor/snyk-monitor     created
11+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRole         snyk-monitor                  created
12+   │  ├─ kubernetes:rbac.authorization.k8s.io/v1:ClusterRoleBinding  snyk-monitor                  created
13+   │  └─ kubernetes:apps/v1:Deployment                               snyk-monitor/snyk-monitor     created
14+   ├─ gcp:container:Cluster                                          pulumi-gke-cluster            created
15+   ├─ pulumi:providers:kubernetes                                    gke_k8s                       created
16+   ├─ kubernetes:core/v1:Namespace                                   snyk-monitor                  created
17+   ├─ kubernetes:core/v1:Namespace                                   apples                        created
18+   ├─ kubernetes:core/v1:Service                                     springboot-employee-api       created
19+   ├─ kubernetes:core/v1:ConfigMap                                   snyk-monitor-custom-policies  created
20+   ├─ kubernetes:core/v1:Secret                                      snyk-monitor                  created
21+   └─ kubernetes:apps/v1:Deployment                                  springboot-employee-api       created
22
23Outputs:
24    kubeconfig: "[secret]"
25
26Resources:
27    + 15 created
28
29Duration: 6m28s

Confira algumas capturas de tela para verificar se tudo foi criado como esperado.

O cluster GKE criado no Google Cloud:

A integração do Snyk com Kubernetes configurada automaticamente:

A carga de trabalho de exemplo importada automaticamente do namespace apples:

Explorando a configuração

Vamos analisar o arquivo Python __main__.py e entender como a integração do Snyk com Kubernetes foi instalada e configurada para nós.

Atualmente, o arquivo de política Rego usado pelo controlador da Snyk está codificado para importar apenas cargas de trabalho do namespace apples, desde que não sejam do tipo CronJob nem Service. Você pode alterar isso em __main__.py e usar um arquivo externo, em vez de deixar a política codificada no código Python:

1snyk_monitor_custom_policies_str = """package snyk
2orgs := ["%s"]
3default workload_events = false
4workload_events {
5input.metadata.namespace == "apples"
6    input.kind != "CronJob"
7    input.kind != "Service"
8}""" % (SNYK_ORG_ID)

Este é o código Python que instala o controlador da Snyk usando seu gráfico Helm. Observe que especificamos o repositório de onde buscar o gráfico Helm, fornecemos o ID da organização da Snyk e incluímos o arquivo de política personalizado mencionado acima. Tudo isso é necessário para instalar o controlador da Snyk no cluster GKE e integrá-lo à Snyk.

1# Deploy the snyk controller using it's helm chart
2snyk_monitor_chart = Chart(
3    "snyk-monitor",
4    ChartOpts(
5        chart="snyk-monitor",
6        version="1.79.0",
7        namespace="snyk-monitor",
8        fetch_opts=FetchOpts(
9            repo="https://snyk.github.io/kubernetes-monitor",
10        ),
11        values={
12          "clusterName": "K8s-integration-demo-cluster",
13          "policyOrgs": "{%s}" % (SNYK_ORG_ID),
14          "workloadPoliciesMap": "snyk-monitor-custom-policies"
15        }
16    ),
17    opts=ResourceOptions(provider=k8s_provider)
18)

O código Python também implantou uma aplicação de exemplo Spring Boot no nosso namespace apples, que foi importada automaticamente pelo controlador da Snyk para o app da Snyk. Veja a seguir o código Python usado para fazer essa implantação:

1# deploy spring boot employee app
2
3"""springboot employee api container, replicated 1 time."""
4app_name = "springboot-employee-api"
5app_labels = { "app": app_name }
6
7springboot_employee_api = k8s.apps.v1.Deployment(
8            app_name,
9            metadata={
10              "namespace": "apples",
11            },
12            spec=k8s.apps.v1.DeploymentSpecArgs(
13                replicas=1,
14                selector=k8s.meta.v1.LabelSelectorArgs(match_labels=app_labels),
15                template=k8s.core.v1.PodTemplateSpecArgs(
16                    metadata=k8s.meta.v1.ObjectMetaArgs(labels=app_labels),
17                    spec=k8s.core.v1.PodSpecArgs(
18                        containers=[
19                            k8s.core.v1.ContainerArgs(
20                                name=app_name,
21                                image="pasapples/springbootemployee:cnb",
22                                ports=[k8s.core.v1.ContainerPortArgs(
23                                  container_port=8080
24                                )]
25                            )
26                        ]
27                    ),
28                ),
29            ),
30            opts=ResourceOptions(provider=k8s_provider)
31)

Etapa 7: Recupere a configuração do Kubernetes

Agora, você pode usar essa configuração no arquivo ~/.kube/config ou salvá-la localmente e defini-la na variável de ambiente KUBECONFIG. Naturalmente, todos os seus comandos habituais do Google Cloud também funcionarão.

Por exemplo:

1$ pulumi stack output kubeconfig --show-secrets > kubeconfig.yaml
2$ KUBECONFIG=./kubeconfig.yaml kubectl get po -n apples
3NAME                                                READY   STATUS    RESTARTS   AGE
4springboot-employee-api-fyrj9hr2-66d8456f5f-hqqhx   1/1     Running   0          17m

O controlador da Snyk instalado no namespace snyk-monitor, além do mapa de configuração e do segredo agora gerenciados pelo Pulumi, exibidos com alguns comandos kubectl:

1$ kubectl get all -n snyk-monitor
2NAME                              READY   STATUS    RESTARTS   AGE
3pod/snyk-monitor-db67744d-szl79   1/1     Running   0          8m52s
4
5NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
6deployment.apps/snyk-monitor   1/1     1            1           8m53s
7
8NAME                                    DESIRED   CURRENT   READY   AGE
9replicaset.apps/snyk-monitor-db67744d   1         1         1       8m53s
10
11$ kubectl get secret -n snyk-monitor -l app.kubernetes.io/managed-by=pulumi
12NAME           TYPE     DATA   AGE
13snyk-monitor   Opaque   2      42m
14
15$ kubectl get configmap -n snyk-monitor -l app.kubernetes.io/managed-by=pulumi
16NAME                           DATA   AGE
17snyk-monitor-custom-policies   1      42m

Etapa 8: Destrua toda a configuração

Quando terminar, você poderá destruir todos os recursos e a stack:

1$ pulumi destroy
2$ pulumi stack rm

Em resumo, você aprendeu como usar o Pulumi para instalar e configurar a integração do Snyk com Kubernetes. Essa integração permite que você importe e teste suas cargas de trabalho em execução e identifique vulnerabilidades nas imagens e configurações associadas que possam comprometer a segurança delas.

Mais recursos

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

• Snyk Container

• Documentação: visão geral da integração com Kubernetes

• Documentação: importação e exclusão automáticas de projetos de cargas de trabalho do Kubernetes

• Aprenda Rego com o excelente curso da Styra