Por que Kubernetes está ficando tão popular?

Na época deste artigo, Kubernetes tem cerca de seis anosde idade , e nos últimos dois anos, aumentou em popularidade para ser consistentemente uma das plataformas mais amadas. Este ano, ele vem como a plataforma número três mais amada. Se você ainda não ouviu falar sobre Kubernetes, é uma plataforma que permite que você execute e orquessine cargas de trabalho de contêineres.

Os contêineres começaram como uma construção de isolamento de processos de kernel Linux que abrange cgroups a partir de 2007 e namespaces a partir de 2002. Os contêineres tornaram-se mais uma coisa quando o LXC se tornou disponível em 2008, e o Google desenvolveu seu próprio "executar tudo em mecanismo de contêineres" chamado Borg. Avançamos para 2013, e Docker foi lançado e popularizou completamente os contêineres para as massas. Na época, Mesos era a principal ferramenta para orquestrar contêineres, no entanto, não foi tão amplamente adotado. Kubernetes foi lançado em 2015 e rapidamente se tornou o padrão de orquestração de contêineres de fato.

Para tentar entender a popularidade de Kubernetes, vamos considerar algumas perguntas. Quando foi a última vez que os desenvolvedores concordaram em como implantar aplicativos de produção? Quantos desenvolvedores você conhece que executam ferramentas como está fora da caixa? Quantos engenheiros de operações em nuvem hoje não entendem como funcionam as aplicações? Vamos explorar as respostas neste artigo.

Infraestrutura como YAML

Vindo do mundo de Puppet and Chef, uma das grandes mudanças com Kubernetes tem sido a mudança da infraestrutura como código para infraestrutura como dados — especificamente, como YAML. Todos os recursos em Kubernetes que incluem Pods, Configurações, Implantações, Volumes, etc., podem simplesmente ser expressos em um arquivo YAML. Por exemplo:

apiVersion: v1

kind: Pod

metadata:

labels:

app: web

spec:

containers:

- name: front-end

image: nginx

ports:

- containerPort: 80

Essa representação torna mais fácil para os DevOps ou engenheiros de confiabilidade do site expressar totalmente suas cargas de trabalho sem a necessidade de escrever código em uma linguagem de programação como Python, Ruby ou Javascript.

Outros benefícios de ter sua infraestrutura como dados incluem:

Controle de versão de operações git ou Git. Com esta abordagem, você pode manter todos os seus arquivos Kubernetes YAML sob repositórios git, o que permite que você saiba precisamente quando uma mudança foi feita, quem fez a mudança e o que exatamente mudou. Isso leva a mais transparência em toda a organização e melhora a eficiência, evitando a ambiguidade de onde os membros precisam ir para encontrar o que precisam. Ao mesmo tempo, pode facilitar a alteração automática dos recursos da Kubernetes apenas mesclando uma solicitação de tração.

Escalabilidade. Ter recursos definidos como YAML torna super fácil para os operadores de cluster alterar um ou dois números em um recurso Kubernetes para alterar o comportamento de escala. Kubernetes tem Autoscalers de pod horizontal para ajudá-lo a identificar um número mínimo e um número máximo de pods que uma implantação específica precisaria ter que ser capaz de lidar com tempos de tráfego baixos e altos. Por exemplo, se você estiver executando uma implantação que pode precisar de mais capacidade porque o tráfego aumenta repentinamente, você pode alterar maxReplicas de 10 para 20:

apiVersion: autoscaling/v2beta2

kind: HorizontalPodAutoscaler

metadata:

namespace: default

spec:

scaleTargetRef:

apiVersion: apps/v1

kind: Deployment

minReplicas: 1

maxReplicas: 20

metrics:

- type: Resource

resource:

target:

type: Utilization

averageUtilization: 50

Segurança e Controles. YAML é uma ótima maneira de validar o que e como as coisas são implantadas em Kubernetes. Por exemplo, uma das preocupações significativas quando se trata de segurança é se suas cargas de trabalho estão sendo executados como um usuário não raiz. Podemos fazer uso de ferramentas como conftest, um validador YAML/JSON, juntamente com o Open Policy Agent, um validador de políticas para verificar se o SecurityContext de suas cargas de trabalho não permite que um contêiner seja executado como uma raiz. Para isso, os usuários podem usar uma política simples do Agente de Política Aberta como esta:

package main

deny[msg] {

input.kind = "Deployment"

not input.spec.template.spec.securityContext.runAsNonRoot = true

msg = "Containers must not run as root"

}

Integrações de provedores em nuvem. Uma das principais tendências do setor de tecnologia é executar cargas de trabalho nos provedores de nuvem pública. Com a ajuda do componente do provedor de nuvem, a Kubernetes permite que cada cluster se integre ao provedor de nuvem em que está sendo executado. Por exemplo, se um usuário estiver executando um aplicativo em Kubernetes no AWS e quiser que esse aplicativo seja acessível através de um serviço, o provedor de nuvem ajuda a criar automaticamente um serviço LoadBalancer que irá automaticamente providenciar um Amazon Elastic Load Balancer para encaminhar o tráfego para os pods de aplicativos.

Extensibilidade

Kubernetes é muito extensível, e os desenvolvedores adoram isso. Existem um conjunto de recursos existentes como Pods, Implantações, StatefulSetsSecrets, ConfigMapsetc. No entanto, usuários e desenvolvedores podem adicionar mais recursos na forma de Definições de Recursos Personalizados. Por exemplo, se quisermos definir um recurso CronTab poderíamos fazê-lo com algo assim:

apiVersion: apiextensions.k8s.io/v1

kind: CustomResourceDefinition

metadata:

spec:

group: my.org

versions:

- name: v1

served: true

storage: true

Schema:

openAPIV3Schema:

type: object

properties:

spec:

type: object

properties:

cronSpec:

type: string

pattern: '^(\d+|\*)(/\d+)?(\s+(\d+|\*)(/\d+)?){4}$'

replicas:

type: integer

minimum: 1

maximum: 10

scope: Namespaced

names:

plural: crontabs

singular: crontab

kind: CronTab

shortNames:

- ct

Podemos criar um recurso CronTab mais tarde com algo assim:

apiVersion: "my.org/v1"

kind: CronTab

metadata:

spec:

cronSpec: "* * * * */5"

image: my-cron-image

replicas: 5

Outra forma de extensibilidade kubernetes é a sua capacidade de os desenvolvedores escreverem seus próprios Operadores, um processo específico em execução em um cluster Kubernetes que segue o padrão do loop de controle. Um Operador permite que os usuários automatizem o gerenciamento de CRDs (definições de recursos personalizados) conversando com a API kubernetes.

A comunidade possui várias ferramentas que permitem que os desenvolvedores criem seus próprios Operadores. Uma dessas ferramentas é o Operator Framework e seu Operador SDK. O SDK fornece um esqueleto para os desenvolvedores começarem a criar um operador muito rapidamente. Por exemplo, você pode começar em sua linha de comando com algo assim:

$ operator-sdk new my-operator --repo github.com/myuser/my-operator

O que cria toda a caldeira para o seu operador, incluindo arquivos YAML e código Golang:

|____cmd

| |____manager

| | |____main.go

|____go.mod

|____deploy

| |____role.yaml

| |____role_binding.yaml

| |____service_account.yaml

| |____operator.yaml

|____tools.go

|____go.sum

|____.gitignore

|____version

| |____version.go

|____build

| |____bin

| | |____user_setup

| | |____entrypoint

| |____Dockerfile

|____pkg

| |____apis

| | |____apis.go

| |____controller

| | |____controller.go

Então você pode adicionar APIs e um controlador como este:

$ operator-sdk add api --api-version=myapp.com/v1alpha1 --kind=MyAppService

$ operator-sdk add controller --api-version=myapp.com/v1alpha1 --kind=MyAppService

E finalmente construir e empurrar o operador para o seu registro de contêineres:

$ operator-sdk build your.container.registry/youruser/myapp-operator

Se os desenvolvedores precisarem ter ainda mais controle, eles podem modificar o código da caldeira nos arquivos Golang. Por exemplo, para modificar as especificidades do controlador, eles podem fazer alterações no arquivo controller.go

Outro projeto, KUDO,permite criar operadores apenas usando arquivos YAML declarativos . Por exemplo, um operador para Apache Kafka seria definido com algo assim, e permite que os usuários instalem um cluster Kafka em cima de Kubernetes com um par de comandos:

$ kubectl kudo install kafka --instance=my-kafka-name \

-p ZOOKEEPER_URI=zk-zookeeper-0.zk-hs:2181 \

-p ZOOKEEPER_PATH=/my-path -p BROKER_CPUS=3000m \

-p BROKER_COUNT=5 -p BROKER_MEM=4096m \

-p DISK_SIZE=40Gi -p MIN_INSYNC_REPLICAS=3 \

-p NUM_NETWORK_THREADS=10 -p NUM_IO_THREADS=20

Inovação

Nos últimos anos, Kubernetes teve grandes lançamentos a cada três ou quatro meses, o que significa que todos os anos há três ou quatro grandes lançamentos. O número de novos recursos que estão sendo introduzidos não diminuiu, evidenciado por mais de 30 adições diferentes e mudanças em seu último lançamento. Além disso, as contribuições não mostram sinais de desaceleração mesmo durante esses tempos difíceis, como indicado pela atividade do projeto Kubernetes Github.

Os novos recursos permitem aos operadores de cluster mais flexibilidade ao executar uma variedade de cargas de trabalho diferentes. Os engenheiros de software também adoram ter mais controles para implantar suas aplicações diretamente em ambientes de produção.

Comunidade

Outro grande aspecto da popularidade kubernetes é sua forte comunidade. Para começar, Kubernetes foi doado para uma casa neutra em 2015, quando atingiu a versão 1.0: a Cloud Native Computing Foundation.

Há também uma ampla gama de SIGs comunitários (grupos de interesse especial) que visam diferentes áreas em Kubernetes à medida que o projeto avança. Eles adicionam continuamente novos recursos e tornam-no ainda mais fácil de usar.

A Cloud Native Foundation também organiza a CloudNativeCon/KubeCon, que a partir deste ano, é o maior evento de código aberto do mundo. O evento, que normalmente é realizado até três vezes por ano, reúne milhares de tecnólogos e profissionais que querem melhorar kubernetes e seu ecossistema, bem como fazer uso de algumas das novidades lançadas a cada três meses.

Além disso, a Cloud Native Foundation possui um Comitê de Supervisão Técnica que, juntamente com seus SIGs,analisa os projetos novos e existentes das fundações no ecossistema nativo da nuvem. A maioria dos projetos ajuda a melhorar a proposta de valor da Kubernetes.

Por fim, creio que Kubernetes não teria o sucesso que faz sem o esforço consciente da comunidade para ser inclusivo uns com os outros e ser acolhedor para qualquer recém-chegado.

Futuro

Um dos principais desafios que os desenvolvedores enfrentam no futuro é como focar mais nos detalhes do código do que na infraestrutura onde esse código é executado. Para isso, o servidor está emergindo como um dos principais paradigmas arquitetônicos para enfrentar esse desafio. Já existem frameworks muito avançados, como Knative e OpenFaas, que usam Kubernetes para abstrair a infraestrutura do desenvolvedor.

Nós mostramos uma breve olhada em Kubernetes neste artigo, mas esta é apenas a ponta do iceberg. Há muito mais recursos, recursos e configurações que os usuários podem aproveitar. Continuaremos a ver novos projetos e tecnologias de código aberto que melhorem ou evoluam Kubernetes, e como mencionamos, as contribuições e a comunidade não vão a lugar algum.

O Avance Network é uma comunidade fácil de usar que fornece segurança de primeira e não requer muito conhecimento técnico. Com uma conta, você pode proteger sua comunicação e seus dispositivos. O Avance Network não mantém registros de seus dados; portanto, você pode ter certeza de que tudo o que sai do seu dispositivo chega ao outro lado sem inspeção.