Oi, Habr!
No final do verão, queremos lembrar que continuamos trabalhando no tema e decidi publicar um artigo do Stackoverflow demonstrando a situação deste projeto no início de junho.
Aproveite a leitura!
No momento em que este artigo foi escrito, a idade do Kubernetes era de aprox. , e nos últimos dois anos sua popularidade cresceu tanto que é consistentemente classificado entre plataformas. Kubernetes ocupa o terceiro lugar este ano. Para recapitular: Kubernetes é uma plataforma projetada para executar e orquestrar cargas de trabalho em contêineres.
Os contêineres começaram como um design especial para isolar processos no Linux; contêineres incluídos desde 2007 , e desde 2002 – namespaces. Os contêineres foram projetados ainda melhor em 2008, quando foram disponibilizados , e o Google desenvolveu seu próprio mecanismo corporativo interno chamado , onde “todo o trabalho é feito em contêineres”. A partir daqui, avançamos para 2013, quando ocorreu o primeiro lançamento do Docker e os contêineres finalmente se tornaram uma solução popular em massa. Naquela época, a principal ferramenta para orquestração de containers era , embora ele não fosse muito popular. O Kubernetes foi lançado pela primeira vez em 2015, após o qual esta ferramenta se tornou o padrão de fato na área de orquestração de contêineres.
Para tentar entender por que o Kubernetes é tão popular, vamos tentar responder algumas perguntas. Quando foi a última vez que os desenvolvedores conseguiram chegar a um acordo sobre como implantar aplicativos em produção? Quantos desenvolvedores você conhece que usam as ferramentas fornecidas imediatamente? Quantos administradores de nuvem existem hoje que não entendem como os aplicativos funcionam? Veremos as respostas a essas perguntas neste artigo.
Infraestrutura como YAML
No mundo que passou do Puppet e Chef ao Kubernetes, uma das maiores mudanças foi a mudança de “infraestrutura como código” para “infraestrutura como dados” – especificamente, como YAML. Todos os recursos do 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: 80Essa visão torna mais fácil para os profissionais de DevOps ou SRE expressarem totalmente suas cargas de trabalho sem precisar escrever código em linguagens como Python ou Javascript.
Outras vantagens de organizar a infraestrutura como dados incluem:
- GitOps ou controle de versão de operações Git. Essa abordagem permite manter todos os arquivos YAML do Kubernetes em repositórios git, para que você possa rastrear exatamente quando uma alteração foi feita, quem a fez e o que exatamente mudou. Isto aumenta a transparência das operações em toda a organização e melhora a eficiência operacional, eliminando a ambiguidade, especialmente onde os funcionários devem procurar os recursos de que necessitam. Ao mesmo tempo, fica mais fácil fazer alterações automaticamente nos recursos do Kubernetes simplesmente mesclando uma solicitação pull.
- Escalabilidade. Quando os recursos são definidos como YAML, torna-se extremamente fácil para os operadores de cluster alterar um ou dois números em um recurso do Kubernetes, alterando assim a forma como ele é dimensionado. O Kubernetes fornece um mecanismo para escalonamento automático horizontal de pods, que pode ser usado para determinar convenientemente qual o número mínimo e máximo de pods necessários em uma configuração de implantação específica para lidar com níveis baixos e altos de tráfego. Por exemplo, se você implantou uma configuração que requer capacidade adicional devido a um aumento repentino no tráfego, maxReplicas poderá ser alterado 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 é ótimo para avaliar como as coisas são implantadas no Kubernetes. Por exemplo, uma grande preocupação de segurança diz respeito a se suas cargas de trabalho estão sendo executadas como um usuário não administrador. Nesse caso, podemos precisar de ferramentas como , validador YAML/JSON, mais , um validador de política para garantir que o contexto suas cargas de trabalho não permitem que o contêiner seja executado 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 = "Containers must not run as root"
}- Opções de integração com um provedor de nuvem. Uma das tendências mais notáveis na alta tecnologia atual é a execução de cargas de trabalho em provedores de nuvem pública. Usando o componente O Kubernetes permite que qualquer cluster se integre ao provedor de nuvem no qual é executado. Por exemplo, se um usuário executa 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
LoadBalancerque fornecerá automaticamente o balanceador de carga para redirecionar o tráfego para pods de aplicativos.
Expansibilidade
O Kubernetes é muito extensível e os desenvolvedores adoram. Há um conjunto de recursos disponíveis, como pods, implantações, StatefulSets, segredos, ConfigMaps, etc. É verdade que usuários e desenvolvedores podem adicionar outros recursos no formulário .
Por exemplo, se quisermos definir um recurso CronTab, então você poderia 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 mais ou menos assim:
apiVersion: "my.org/v1"
kind: CronTab
metadata:
name: my-cron-object
spec:
cronSpec: "* * * * */5"
image: my-cron-image
replicas: 5
Outra opção de extensibilidade no Kubernetes é que o desenvolvedor pode escrever suas próprias declarações. é um processo especial no cluster Kubernetes que funciona de acordo com o “" Com a ajuda de um operador, o usuário pode automatizar o gerenciamento de CRDs (definições de recursos personalizados) trocando informações com a API Kubernetes.
Existem diversas ferramentas na comunidade que facilitam aos desenvolvedores a criação de seus próprios operadores. Entre eles - e . Este SDK fornece uma base a partir da qual um desenvolvedor pode começar rapidamente a criar um operador. Digamos que você possa iniciar na linha de comando algo assim:
$ operator-sdk new my-operator --repo github.com/myuser/my-operatorIsso cria todo o código padrão 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.goEm seguida, você pode 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=MyAppServiceEntão, por fim, monte a operadora e envie para o registro do seu container:
$ operator-sdk build your.container.registry/youruser/myapp-operator
Se o desenvolvedor quiser ainda mais controle, o código padrão nos arquivos Go pode ser alterado. Por exemplo, para modificar as especificações do controlador, você pode fazer alterações no arquivo controller.go.
Outro projeto , permite criar instruções usando apenas arquivos YAML declarativos. Por exemplo, um operador para Apache Kafka seria definido aproximadamente . Com ele, você pode instalar um cluster Kafka no Kubernetes com apenas alguns comandos:
$ kubectl kudo install zookeeper
$ kubectl kudo install kafkaE então configure-o com outro 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ção
Nos últimos anos, os principais lançamentos do Kubernetes têm sido lançados a cada poucos meses - ou seja, três a quatro lançamentos principais por ano. O número de novos recursos introduzidos em cada um deles não diminui. Além disso, não há sinais de abrandamento, mesmo nestes tempos difíceis - veja como está a situação agora .
Novos recursos permitem agrupar operações em cluster com mais flexibilidade em diversas cargas de trabalho. Além disso, os programadores desfrutam de maior controle ao implantar aplicativos diretamente na produção.
Comunidade
Outro aspecto importante da popularidade do Kubernetes é a força de sua comunidade. Em 2015, ao chegar à versão 1.0, o Kubernetes foi patrocinado pela .
Existem também várias comunidades (Grupos de Interesse Especial) focados em trabalhar em diferentes áreas do Kubernetes conforme o projeto evolui. Esses grupos estão constantemente adicionando novos recursos, tornando o trabalho com o Kubernetes mais conveniente e conveniente.
A Cloud Native Foundation também hospeda CloudNativeCon/KubeCon, que, no momento em que este artigo foi escrito, é a maior conferência de código aberto do mundo. Normalmente realizado três vezes ao ano, reúne milhares de profissionais que desejam aprimorar o Kubernetes e seu ecossistema, além de conhecer novas funcionalidades que surgem a cada três meses.
Além disso, a Cloud Native Foundation , que, juntamente com os SIGs, analisa novos e existentes fundos focados 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 tanto sucesso sem os esforços conscientes de toda a comunidade, onde as pessoas permanecem unidas, mas ao mesmo tempo acolhem os recém-chegados.
O futuro
Um dos principais desafios que os desenvolvedores terão de enfrentar no futuro é a capacidade de focar nos detalhes do código em si, e não na infraestrutura em que ele é executado. Ele atende a essas tendências , que é um dos líderes hoje. Já existem estruturas avançadas, por ex. и , que usa Kubernetes para abstrair a infraestrutura do desenvolvedor.
Neste artigo, apenas arranhamos a superfície do estado atual do Kubernetes – na verdade, é apenas a ponta do iceberg. Os usuários do Kubernetes têm muitos outros recursos, capacidades e configurações à sua disposição.
Fonte: habr.com