Olá, Habr!
No final do verão, queremos lembrar que continuamos a trabalhar no tema e decidimos publicar um artigo do Stackoverflow, demonstrando a situação deste projeto no início de junho.
Boa leitura!
No momento em que este artigo foi escrito, a idade do Kubernetes é de cerca de , e nos últimos dois anos sua popularidade cresceu tanto que ele está consistentemente entre os plataformas. Este ano, o Kubernetes ocupa o terceiro lugar. Lembre-se: Kubernetes é uma plataforma destinada a executar e orquestrar cargas de trabalho em contêineres.
Contêineres surgiram como uma construção especial para isolar processos no Linux; desde 2007, eles incluem , e desde 2002 - espaços de nome. Os contêineres se consolidaram ainda melhor em 2008, quando se tornou disponível , e o Google desenvolveu seu mecanismo interno chamado , onde "todo o trabalho é realizado em contêineres". Vamos então para 2013, quando ocorreu o primeiro lançamento do Docker, e os contêineres finalmente se tornaram soluções populares. Naquele momento, a principal ferramenta para orquestração de contêineres era , embora não tenha sido muito popular. O primeiro lançamento do Kubernetes ocorreu em 2015, depois do qual essa ferramenta se tornou de fato o padrão na área de orquestração de contêineres.
Para tentar entender por que o Kubernetes é tão popular, vamos tentar responder a algumas perguntas. Quando foi a última vez que os desenvolvedores conseguiram chegar a um consenso sobre como implantar aplicações em produção? Quantos desenvolvedores você conhece que usam ferramentas na forma como são fornecidas "da caixa"? Quantos administradores de nuvem hoje não entendem como as aplicações funcionam? Vamos analisar as respostas a essas perguntas neste artigo.
Infraestrutura como YAML
Em um mundo que passou do Puppet e Chef para o Kubernetes, uma das maiores mudanças foi a transição de "infraestrutura como código" para "infraestrutura como dados" — especificamente, como YAML. Todos os recursos no Kubernetes, que incluem pods, configurações, instâncias implantadas, volumes, etc., podem ser facilmente descritos em um arquivo YAML. Por exemplo:
apiVersion: v1
kind: Pod
metadata:
name: site
labels:
app: web
spec:
containers:
- name: front-end
image: nginx
ports:
- containerPort: 80Com essa apresentação, é mais fácil para os especialistas em DevOps ou SRE expressar completamente suas cargas de trabalho, sem a necessidade de escrever código em linguagens como Python ou Javascript.
Outras vantagens da organização da infraestrutura de dados são as seguintes:
- GitOps ou controle de versão Git Operations Version. Essa abordagem permite manter todos os arquivos YAML do Kubernetes em repositórios git, permitindo que você rastreie exatamente quando uma alteração foi feita, quem a fez e o que realmente mudou. Isso aumenta a transparência das operações em toda a organização, melhorando a eficiência ao eliminar ambiguidades, especialmente sobre onde os colaboradores devem procurar os recursos de que precisam. Ao mesmo tempo, torna mais fácil fazer alterações automaticamente nos recursos do Kubernetes – simplesmente por meio da fusão de pull requests.
- Escalabilidade. Quando os recursos são definidos em YAML, torna-se extremamente simples para os operadores de cluster alterar um ou dois números nos recursos do Kubernetes, alterando assim os princípios de sua escalabilidade. O Kubernetes tem um mecanismo para escalonamento automático horizontal de pods, que facilita a definição de qual é o número mínimo e máximo de pods necessários em uma configuração específica implantada, para lidar com baixos e altos níveis de tráfego. Por exemplo, se você implantou uma configuração que requer capacidade adicional devido a um aumento repentino de tráfego, pode alterar o número maxReplicas de 10 para 20:
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
name: myapp
namespace: default
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: myapp-deployment
minReplicas: 1
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50- Segurança e gerenciamento. YAML é excelente para avaliar como as coisas estão sendo implantadas no Kubernetes. Por exemplo, um problema sério relacionado à segurança diz respeito a se suas cargas de trabalho estão sendo executadas de um usuário que não possui privilégios de administrador. Nesse caso, podemos precisar de ferramentas como , um validador YAML/JSON, além de , um validador de políticas que garante que o contexto as suas cargas de trabalho não permitem que o contêiner funcione com privilégios de administrador. Se isso for necessário, os usuários podem aplicar uma política simples , assim:
package main
deny[msg] {
input.kind = "Deployment"
not input.spec.template.spec.securityContext.runAsNonRoot = true
msg = "Os contêineres não devem ser executados como root"
}- Opções de integração com provedores de nuvem. Uma das tendências mais notáveis na tecnologia moderna é executar cargas de trabalho nas infraestruturas de provedores de nuvem públicos. Com o componente o Kubernetes permite que qualquer cluster se integre com o provedor de nuvem no qual está operando. Por exemplo, se um usuário iniciou um aplicativo no Kubernetes na AWS e deseja expor esse aplicativo por meio de um serviço, o provedor de nuvem ajuda a criar automaticamente o serviço
LoadBalancer, que fornecerá automaticamente um balanceador de carga , para redirecionar o tráfego para os pods do aplicativo.
Escalabilidade
O Kubernetes é muito escalável, o que agrada os desenvolvedores. Há um conjunto de recursos disponíveis, como pods, implantações, StatefulSets, segredos, ConfigMaps, etc. Na verdade, os usuários e desenvolvedores podem adicionar outros recursos na forma de .
Por exemplo, se quisermos definir um recurso CronTab, poderíamos fazer algo assim:
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: crontabs.my.org
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
Mais tarde, podemos criar um recurso CronTab aproximadamente desta forma:
apiVersion: "my.org/v1"
kind: CronTab
metadata:
name: my-cron-object
spec:
cronSpec: "* * * * */5"
image: my-cron-image
replicas: 5
Outra opção de escalabilidade no Kubernetes é que o desenvolvedor pode escrever seus próprios operadores. – é um processo especial no cluster Kubernetes que opera pelo padrão "". Com o operador, o usuário pode automatizar a gestão de CRDs (definições de recursos personalizados), trocando informações com a API do Kubernetes.
Na comunidade, existem várias ferramentas que permitem que os desenvolvedores criem seus próprios operadores de forma conveniente. Entre elas está e seu . Este SDK fornece uma base a partir da qual o desenvolvedor pode rapidamente começar a criar um operador. Por exemplo, pode-se iniciar pelo terminal assim:
$ operator-sdk new my-operator --repo github.com/myuser/my-operatorAssim, todo o código padrão para o seu operador é gerado, incluindo arquivos YAML e código em 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.goEm seguida, pode-se adicionar as APIs e o controlador necessários, assim:
$ operator-sdk add api --api-version=myapp.com/v1alpha1 --kind=MyAppService
$ operator-sdk add controller --api-version=myapp.com/v1alpha1 --kind=MyAppServiceDepois disso, finalmente, compile o operador e envie-o para o seu registro de contêiner:
$ operator-sdk build your.container.registry/youruser/myapp-operator Se o desenvolvedor precisar de um controle ainda mais completo, pode modificar o código padrão nos arquivos Go. Por exemplo, para alterar a especificidade do controlador, pode fazer alterações no arquivo controller.go.
Outro projeto, , permite criar operadores usando apenas arquivos YAML declarativos. Por exemplo, um operador para o Apache Kafka será definido mais ou menos . Com isso, é possível instalar um cluster Kafka sobre o Kubernetes com apenas alguns comandos:
$ kubectl kudo install zookeeper
$ kubectl kudo install kafkaE então configurá-lo com mais um comando:
$ 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ções
Nos últimos anos, grandes lançamentos do Kubernetes têm ocorrido a cada poucos meses – ou seja, de três a quatro grandes lançamentos por ano. O número de novos recursos implementados em cada um deles não diminui. Além disso, não há sinais de desaceleração, mesmo em nossos tempos complicados – veja como está atualmente .
Novas funcionalidades permitem uma clusterização mais flexível das operações quando há diversas cargas de trabalho. Além disso, os programadores apreciam ter um controle mais abrangente ao implantar aplicações diretamente em produção.
A comunidade
Outro aspecto importante da popularidade do Kubernetes é a força de sua comunidade. Em 2015, ao alcançar a versão 1.0, o Kubernetes foi patrocinado .
Existem também diversas comunidades (Grupos Especiais de Interesse), focados em desenvolver diferentes áreas do Kubernetes à medida que este projeto avança. Esses grupos estão constantemente adicionando novas funcionalidades, tornando o uso do Kubernetes cada vez mais conveniente.
A Cloud Native Foundation também realiza o CloudNativeCon/KubeCon, que, no momento da redação deste texto, é a maior conferência de código aberto do mundo. Normalmente é realizada três vezes ao ano e reúne milhares de profissionais que desejam aprimorar o Kubernetes e seu ecossistema, além de aprender sobre novas funcionalidades que surgem a cada três meses.
Além disso, na Cloud Native Foundation existe , que, juntamente com os SIGs, analisa novos e existentes da fundação que se concentram no ecossistema de nuvem. A maioria desses projetos ajuda a melhorar os pontos fortes do Kubernetes.
Por fim, acredito que o Kubernetes não teria alcançado tal sucesso sem os esforços conscientes de toda a comunidade, onde as pessoas se apoiam mutuamente, mas ao mesmo tempo, recebem de braços abertos os novatos.
O Futuro
Um dos principais desafios que os desenvolvedores enfrentarão no futuro é a capacidade de se concentrar nos detalhes do próprio código, e não na infraestrutura em que ele opera. Essa tendência é atendida pela , que é uma das mais proeminentes atualmente. Já existem frameworks avançados, como e , que utilizam o Kubernetes para abstrair a infraestrutura do desenvolvedor.
Neste artigo, abordamos apenas de forma geral o estado atual do Kubernetes – na verdade, isso é apenas a ponta do iceberg. Os usuários do Kubernetes têm à sua disposição muitos outros recursos, funcionalidades e configurações.
Fonte: habr.com
