O futuro da orquestração de contêineres: explorando soluções de orquestração de microsserviços baseadas em Kubernetes

Autor: Zen e a Arte da Programação de Computadores

1. Introdução

No atual ambiente de computação em nuvem, a tecnologia de contêineres está se tornando dominante e cada vez mais empresas optam por implementar a implantação e operação de aplicativos com base na tecnologia de contêineres. A tecnologia de orquestração de contêineres também está ganhando ampla adoção. Arquiteturas complexas de sistemas distribuídos podem ser implantadas, gerenciadas e expandidas por meio de ferramentas de orquestração de contêineres para fornecer um ambiente de cluster altamente disponível, fácil de manter e elasticamente escalável. Este artigo discute principalmente soluções de orquestração de microsserviços baseados em Kubernetes.

Em 2017, foi lançado o projeto Kubernetes (K8s para abreviar), uma estrutura de orquestração de contêineres de código aberto que fornece uma maneira fácil de criar, configurar e gerenciar aplicativos em contêineres. O K8s fornece uma série de funções, como gerenciamento de recursos de cluster, agendamento automático, autocorreção, descoberta de serviço e balanceamento de carga.

No final de 2018, o projeto Istio anunciou sua entrada na incubadora CNCF (Cloud Native Computing Foundation), um produto de código aberto para conectar, gerenciar, proteger, monitorar e observar microsserviços. O Istio é um superconjunto de K8s, com uma arquitetura de malha de serviço (Service Mesh), que permite comunicação segura e transparente entre microsserviços e fornece observabilidade, elasticidade, telemetria, aplicação de políticas e recursos avançados de controle de roteamento. Com base no Istio, as empresas podem criar rapidamente uma arquitetura de microsserviço para obter desacoplamento de aplicativos, governança de serviços, observabilidade e dimensionamento elástico.

Em agosto de 2019, a comunidade KubeSphere o lançou oficialmente no Linux China Summit, um projeto de alto nível da Fundação Apache. É uma plataforma de contêiner de nuvem híbrida e multinuvem baseada em K8s. Ele fornece uma interface de operação leve e visual completa, permitindo que os usuários gerenciem vários objetos do Kubernetes de maneira mais conveniente. KubeSphere suporta expansão automática sob demanda, dimensionamento elástico, monitoramento abrangente e alarme, consulta de log, auditoria, liberação de escala de cinza, gerenciamento de armazenamento, gerenciamento de rede, etc., para criar uma plataforma de contêiner forte para usuários, ajudar as empresas a implementar o conceito DevOps, e melhorar o desempenho da agilidade de negócios, eficiência operacional e recursos de otimização de custos.

Em 2020, o produto Tencent Cloud Container Service TKEStack anunciou a conclusão dos serviços de hospedagem de infraestrutura K8s. O TKEStack fornecerá uma série de serviços, incluindo dimensionamento elástico, rede, armazenamento, monitoramento, segurança, etc., para que as empresas possam se concentrar na pesquisa e desenvolvimento de negócios e acelerar a transformação e atualização de TI.

K8s e Istio se tornaram uma das tecnologias mais influentes e atraentes no campo da orquestração de contêineres. Eles são todos baseados na tecnologia Docker, que permite gerenciamento e implantação de cluster entre hosts, nós e nuvens cruzadas. O Kubernetes possui recursos completos de descoberta de serviço e balanceamento de carga, levando em consideração recursos como alta disponibilidade, dimensionamento elástico, armazenamento persistente e rede. O Istio fornece uma arquitetura de grade de serviço que oferece suporte a muitas funções, incluindo limitação de corrente, quebra de circuito, controle de acesso, monitoramento etc., para ajudar as empresas a criar e gerenciar arquiteturas de microsserviços. KubeSphere e TKEStack fizeram grandes avanços no campo do arranjo de contêineres, o que trará grande valor para as empresas.

Com o rápido desenvolvimento da computação em nuvem e da tecnologia de contêineres, a tecnologia de orquestração de contêineres também enfrenta novos desafios.

Em agosto de 2019, o Docker anunciou a aquisição do Moby, uma estrutura de orquestração de contêineres, como uma das pilhas de tecnologia de camada básica do Docker. No entanto, tecnologias antigas, como Docker Compose e Swarm, ainda estão em uso, e muitas ferramentas excelentes de orquestração de contêineres, como Prometheus e Grafana, estão sendo desenvolvidas para ajudar os administradores a gerenciar arquiteturas complexas de sistemas distribuídos com mais facilidade. Portanto, para estabelecer uma verdadeira arquitetura de aplicativo nativa da nuvem, é necessário combinar uma série de tecnologias, como plataforma de nuvem, IaaS, PaaS e microsserviços, em vez de se limitar à tecnologia de orquestração de contêineres.

Em 2020, o CNCF (Cloud Native Computing Foundation, Cloud Native Computing Foundation) lançou um white paper chamado "Cloud Native Application Definition", que descreve o modelo de arquitetura de aplicativo nativo em nuvem. De acordo com o white paper, a arquitetura de aplicativos nativos da nuvem é um novo paradigma de arquitetura baseado no modelo de arquitetura de microsserviços e na metodologia DevOps. gerenciamento de engenharia de software. , dando ao aplicativo uma maior vitalidade. Para realizar essa arquitetura, fornecedores de nuvem, organizações de código aberto e empresas devem cooperar para promover conjuntamente a popularização e o desenvolvimento de tecnologias nativas de nuvem.

2. Explicação dos conceitos e termos básicos

Esta seção apresenta principalmente o conhecimento relevante da arquitetura de microsserviços e da tecnologia de orquestração de contêineres.

1. Arquitetura de microsserviços

A arquitetura de microsserviço é um padrão de arquitetura de serviço que divide um único aplicativo ou sistema em pequenos serviços independentes, cada um dos quais é executado em seu próprio processo e se comunica entre si por meio de um protocolo de comunicação leve (geralmente HTTP API) para se comunicar. Cada serviço é responsável por lidar com uma função de negócios ou processo de negócios específico. Ao contrário da arquitetura monolítica tradicional, a arquitetura de microsserviço permite que cada serviço seja implantado, iterado, evoluído e dimensionado de forma independente conforme necessário.

Os microsserviços são um modelo de arquitetura popular em sistemas distribuídos, não é uma bala de prata, então não espere que a arquitetura de microsserviço resolva todos os problemas. A arquitetura de microsserviços resolve principalmente como desenvolver e implantar rapidamente nossos serviços, o que é muito necessário para uma empresa que pode se adaptar ao rápido desenvolvimento e crescimento.

Microsserviços é uma abordagem de projeto de arquitetura em que cada serviço (serviço) dessa arquitetura é projetado para um conjunto de funções e se concentra na resolução de um problema específico. Se os desenvolvedores adicionarem gradualmente mais código a um serviço e o serviço se tornar complexo, ele poderá ser dividido em vários serviços menores. Em seguida, realize desenvolvimento, teste, implantação, operação e manutenção independentes. Por sua vez, ele pode lidar melhor com as solicitações dos clientes e com mais flexibilidade e melhorar a confiabilidade e a escalabilidade do sistema.

2. Malha de Serviço

Service Mesh é uma camada de infraestrutura para comunicação entre serviços. Consiste em um conjunto de proxies de rede leves que encapsulam chamadas de serviço e fornecem funções como observabilidade, controle, segurança e roteamento, tornando a comunicação entre serviços em aplicativos de microsserviços confiável, eficiente e transparente.

3. Kubernetes

O Kubernetes é um sistema de orquestração de contêineres de código aberto para gerenciar aplicativos em contêineres. Com base no sistema Borg interno do Google, ele fornece agendamento, planejamento, isolamento e gerenciamento automáticos de recursos de cluster para aplicativos em contêineres. Ele foi projetado para tornar a implantação simples, a entrega consistente e a expansão fácil.

4. Imagem do contêiner

Uma imagem de contêiner é uma tecnologia de empacotamento de software que empacota o software e suas dependências em um arquivo padronizado que pode ser executado em qualquer sistema operacional Linux ou Windows, seja físico ou virtual. A imagem do container é desenvolvida com base no Docker e pode ser entendida como uma versão da imagem do Docker.

5. Dockerfile

Dockerfile é um arquivo de texto usado para criar uma imagem personalizada do Docker, que registra como construir a imagem. Em geral, um Dockerfile contém todas as instruções e comandos necessários para criar uma imagem.

6. Elmo

O Helm é uma ferramenta de gerenciamento de pacotes Kubernetes que pode ajudar a gerenciar o ciclo de vida dos aplicativos Kubernetes. O Helm pode instalar, atualizar, reverter e gerenciar gráficos. Um gráfico é um conjunto de arquivos yaml que descrevem um pacote no Kubernetes, como Prometheus ou MySQL. Os gráficos podem ser empacotados em um repositório Helm compartilhado ou em um repositório de gráficos privado.

7. Descoberta de serviço e balanceamento de carga

A descoberta de serviço e o balanceamento de carga referem-se à descoberta e distribuição entre serviços, respectivamente. Quando os serviços são iniciados, eles são registrados em um registro de serviço por meio do qual outros serviços podem descobrir e solicitar esses serviços. O balanceamento de carga refere-se ao direcionamento do tráfego para determinadas instâncias de serviço de acordo com determinadas regras. Normalmente, um balanceador de carga detecta que determinados serviços estão inativos ou respondendo lentamente e redistribui o tráfego para instâncias de serviço íntegras.

8. Entrada

Ingress é um objeto de recurso no K8S, responsável por expor serviços especificados de acordo com a entrada de acesso. Ele usa uma coleção de regras para corresponder às solicitações do cliente e configura dinamicamente os serviços de back-end correspondentes em segundo plano.

9. Prometeu

O Prometheus é um sistema de monitoramento e alerta de código aberto que pode coletar, armazenar e extrair dados de séries temporais. A linguagem de consulta PromQL fornecida pelo Prometheus pode ajudar os usuários a consultar, agregar, fatiar, filtrar e outras operações em dados de séries temporais.

10. Grafana

O Grafana é uma ferramenta de análise visual de código aberto que pode apresentar visualmente os resultados da visualização dos dados de monitoramento no Prometheus. Ao visualizar os dados da série temporal, os usuários podem obter informações sobre a operação geral do sistema.

3. Princípios básicos do algoritmo, etapas de operação específicas e explicação da fórmula matemática

3.1 Arquitetura de malha de serviço

A arquitetura de grade de serviço é um padrão de arquitetura que abstrai a comunicação entre serviços em uma rede semelhante a grade, cada unidade de grade representa um serviço e o nó de borda representa um cliente. A comunicação entre os serviços é realizada através dos nós de borda na grade e por meio de chamadas mútuas entre várias unidades da grade.

Os benefícios de uma arquitetura de malha de serviço são:

1. A comunicação entre os serviços é controlada uniformemente, o acoplamento entre os serviços é reduzido e a confiabilidade dos serviços é aprimorada.

2. Fornece funções como gerenciamento de tráfego, segurança e observabilidade e forma um gerenciamento abrangente de toda a arquitetura de serviço.

3. Por meio do lançamento em escala de cinza, teste de várias versões, etc., novas funções, novas versões e problemas online podem ser enviados automaticamente para o ambiente de produção com um clique.

4. Mais adequado para arquitetura de microsserviços. Devido às características fracamente acopladas e modularizadas da arquitetura de microsserviços, as dependências entre os serviços são mais complicadas, caso não haja grade de serviços, é necessário implementar a comunicação entre os serviços através da lógica de negócios. Mas na grade de serviço, toda a comunicação pode ser realizada através dos nós de borda na grade por meio do plano de controle, para que todas as dependências da lógica de negócios possam ser eliminadas e a comunicação entre serviços totalmente automatizada possa ser realizada.

3.2 Uso básico do Helm

Helm é um gerenciador de pacotes para Kubernetes. Ele ajuda você a implantar e gerenciar rapidamente aplicativos Kubernetes, tanto de código aberto quanto proprietários. A arquitetura do Helm é semelhante ao Docker Hub ou GitHub. O Helm tem dois componentes: o Helm CLI (Helm Command Line Interface) e o repositório Helm. A CLI usa gráficos Helm para instalar aplicativos Kubernetes e interagir com repositórios Helm.

Instalação do leme:

1. O endereço de download do pacote de instalação do Helm é https://get.helm.sh/

2. Execute o seguinte comando para instalar:

   curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
   

3. Verifique se o Helm foi instalado com sucesso:

   helm version
   

   Se as informações do número da versão forem exibidas, isso significa que o Helm foi instalado com sucesso.

Estrutura do gráfico do leme:

chart/
  Chart.yaml          # 包含 chart 信息的 YAML 文件
  templates/          # 模板目录
    deployment.yaml   # Deployment 的模板文件
    service.yaml      # Service 的模板文件
  values.yaml         # 包含默认值的 YAML 文件
  requirements.yaml   # 描述了 chart 所依赖的其它 chart 的 YAML 文件

Chart.yaml：

apiVersion: v2
name: mychart
description: A Helm chart for Kubernetes
version: 0.1.0
appVersion: 1.0.0

valores.yaml：

replicaCount: 1
image:
  repository: nginx
  tag: stable
  pullPolicy: IfNotPresent
ingress:
  enabled: true
  annotations: {}
    # kubernetes.io/ingress.class: nginx
    # kubernetes.io/tls-acme: "true"
  path: /
  hosts:
    - host: chart-example.local
      paths: []
  tls: []
  #  - secretName: chart-example-tls
  #    hosts:
  #      - chart-example.local
resources: {}
  # We usually recommend not to specify default resources and to leave this as a conscious
  # choice for the user. This also increases chances charts run on environments with little
  # resources, such as Minikube. If you do want to specify resources, uncomment the following
  # lines, adjust them as necessary, and remove the curly braces after'resources:'.
  # limits:
  #   cpu: 100m
  #   memory: 128Mi
  # requests:
  #   cpu: 100m
  #   memory: 128Mi
nodeSelector: {}
affinity: {}
tolerations: []

templates/deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {
   
   { include.Values.fullname }}
  labels:
    app.kubernetes.io/name: {
   
   { include.Chart.Name }}
    helm.sh/chart: {
   
   { include.Chart.Name }}-{
   
   { include.Chart.Version | replace "+" "_" }}
    app.kubernetes.io/instance: {
   
   {.Release.Name }}
    app.kubernetes.io/managed-by: {
   
   {.Release.Service }}
spec:
  replicas: {
   
   {.Values.replicaCount }}
  selector:
    matchLabels:
      app.kubernetes.io/name: {
   
   { include.Chart.Name }}
      app.kubernetes.io/instance: {
   
   {.Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/name: {
   
   { include.Chart.Name }}
        app.kubernetes.io/instance: {
   
   {.Release.Name }}
    spec:
      containers:
        - name: {
   
   {.Chart.Name }}
          image: "{
   
   {.Values.image.repository }}:{
   
   {.Values.image.tag }}"
          imagePullPolicy: "{
   
   {.Values.image.pullPolicy }}"
          ports:
            - name: http
              containerPort: 80
              protocol: TCP
          livenessProbe:
            httpGet:
              path: /healthz
              port: http
          readinessProbe:
            httpGet:
              path: /readiness
              port: http
          resources:
{
   
   { toYaml.Values.resources | indent 12 }}
      affinity:
{
   
   { toYaml.Values.affinity | indent 8 }}
      nodeSelector:
{
   
   { toYaml.Values.nodeSelector | indent 8 }}
      tolerations:
{
   
   { toYaml.Values.tolerations | indent 8 }}
---
apiVersion: v1
kind: Service
metadata:
  name: {
   
   { include.Values.fullname }}
  labels:
    app.kubernetes.io/name: {
   
   { include.Chart.Name }}
    helm.sh/chart: {
   
   { include.Chart.Name }}-{
   
   { include.Chart.Version | replace "+" "_" }}
    app.kubernetes.io/instance: {
   
   {.Release.Name }}
    app.kubernetes.io/managed-by: {
   
   {.Release.Service }}
spec:
  type: ClusterIP
  ports:
    - port: 80
      targetPort: http
      protocol: TCP
      name: http
  selector:
    app.kubernetes.io/name: {
   
   { include.Chart.Name }}
    app.kubernetes.io/instance: {
   
   {.Release.Name }}

Etapa 1: crie uma nova pasta de projeto do Helm.

mkdir myproject && cd myproject

Etapa 2: inicializar o repositório do Helm.

helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

Etapa 3: crie um novo arquivo Chart.yaml e declare o nome e a versão do gráfico.

cat > Chart.yaml <<EOF
apiVersion: v2
name: hello-world
version: 0.1.0
appVersion: 1.0.0
EOF

Etapa 4: crie um novo arquivo deployment.yaml no diretório templates/ para descrever a implantação.

cat > templates/deployment.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {
    
    { include.Values.fullname }}
  labels:
    app.kubernetes.io/name: {
    
    { include.Chart.Name }}
    helm.sh/chart: {
    
    { include.Chart.Name }}-{
    
    { include.Chart.Version | replace "+" "_" }}
    app.kubernetes.io/instance: {
    
    {.Release.Name }}
    app.kubernetes.io/managed-by: {
    
    {.Release.Service }}
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: {
    
    { include.Chart.Name }}
      app.kubernetes.io/instance: {
    
    {.Release.Name }}
  template:
    metadata:
      labels:
        app.kubernetes.io/name: {
    
    { include.Chart.Name }}
        app.kubernetes.io/instance: {
    
    {.Release.Name }}
    spec:
      containers:
        - name: web
          image: "nginx:latest"
          ports:
            - name: http
              containerPort: 80
EOF

Passo 5: Gerar helmpack.

helm package. --destination./release

Etapa 6: carregue o helmpack no repositório do Helm.

helm repo index./ --url https://wongcyrus.github.io/helmpack/

Etapa 7: adicionar fontes ao Helm.

helm repo add myrepo https://wongcyrus.github.io/helmpack/
helm repo list

Passo 8: Instale o helmpack.

helm install myproject myrepo/hello-world

Etapa 9: verifique o status de instalação do leme.

kubectl get all

4. O que é Enviado

https://www.cnblogs.com/aquester/p/12160114.html

O Envoy é uma implementação C++ do proxy de código aberto da Lyft (Proxy). Semelhante ao Nginx e HAProxy, ele pode fazer proxy da camada L3/L4 e da camada L7. Proxy é sua função principal e básica, e também é o sidecar da estrutura de grade de serviço Istio.

5. Combate real do projeto: use Spring Boot para implementar rapidamente um desenvolvimento de código de microsserviço e implantação do Docker

Esta seção apresentará como usar o Spring Boot para implementar rapidamente o desenvolvimento de código e a implantação do Docker de microsserviços. Usaremos um projeto de exemplo simples para demonstrar o processo. Neste projeto de exemplo, criaremos uma API RESTful simples que retorna alguns dados embutidos em código.

preparação do projeto

Antes de começarmos a escrever o código, precisamos fazer algum trabalho preparatório. Primeiro, precisamos garantir que as seguintes ferramentas estejam instaladas em nosso ambiente de desenvolvimento:

• Java JDK 8 ou posterior
• Especialista
• Docker

Em seguida, criaremos um novo projeto Spring Boot. Podemos usar o Spring Initializr para criar projetos, o que pode nos ajudar a gerar rapidamente um novo projeto Spring Boot. Podemos acessar o Spring Initializr visitando https://start.spring.io/ ↗ .

No Spring Initializr, precisamos especificar as informações básicas do projeto, como nome do projeto, descrição, nome do pacote, etc. Também precisamos escolher a versão do Spring Boot e as ferramentas de compilação que queremos usar. Neste projeto de exemplo, usaremos Spring Boot 2.5.2 e Maven como ferramenta de construção. Também precisamos adicionar algumas dependências do projeto para que possamos usar o Spring Web para criar uma API RESTful. Neste projeto de exemplo, precisamos adicionar as seguintes dependências:

• web de primavera
• Spring Boot DevTools

Depois de concluir o acima, podemos gerar um novo projeto Spring Boot.

Escrever código

Agora, estamos prontos para começar a escrever o código. Criaremos uma API RESTful simples que retorna alguns dados embutidos em código. Podemos criar uma nova classe Spring Boot Controller para lidar com solicitações HTTP.

@RestController
public class HelloWorldController {
    
    

    @GetMapping("/hello")
    public String helloWorld() {
    
    
        return "Hello, world!";
    }
}

Neste código de exemplo, criamos uma HelloWorldControllerclasse chamada que usa @RestControlleranotações para especificar que é um controlador de API RESTful. Também criamos um helloWorldmétodo chamado que lida com solicitações HTTP GET e retorna uma string codificada.

construir projeto

Antes de podermos implantar nosso aplicativo, precisamos construir nosso projeto. Podemos usar o Maven para construir nosso projeto. Execute o seguinte comando no diretório raiz do projeto:

mvn clean package

Este comando usará o Maven para compilar nosso código e gerar um arquivo JAR executável.

Implantar no Docker

Agora, estamos prontos para implantar nosso aplicativo no Docker. Precisamos criar um Dockerfile para especificar como nossa imagem Docker deve ser construída. Crie um arquivo nomeado no diretório raiz do projeto Dockerfilee adicione o seguinte conteúdo:

FROM openjdk:8-jdk-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Neste Dockerfile, estamos usando uma openjdk:8-jdk-alpineimagem base chamada como nossa imagem Docker. Também usamos um ARGcomando para especificar os arquivos JAR que queremos copiar para a imagem do Docker. Usaremos COPYo comando para copiar o arquivo JAR para a imagem do Docker. Por fim, usamos ENTRYPOINTo comando para especificar como nossa imagem do Docker deve iniciar nosso aplicativo.

Em seguida, precisamos executar o seguinte comando no diretório raiz do projeto para criar nossa imagem do Docker:

docker build -t myapp .

Este comando usará nosso Dockerfile para criar uma myappimagem do Docker chamada .

Por fim, podemos executar nossa imagem do Docker com o seguinte comando:

docker run -p 8080:8080 myapp

Este comando iniciará nossa imagem do Docker e mapeará a porta 8080 do contêiner para a porta 8080 de nossa máquina local. Agora, podemos acessar nosso aplicativo visitando http://localhost:8080/hello ↗ .

Resumir

Neste artigo, apresentamos como usar o Spring Boot para implementar rapidamente o desenvolvimento de código e a implantação do Docker de microsserviços. Criamos uma API RESTful simples e a compilamos em um arquivo JAR executável usando Maven. Em seguida, usamos o Dockerfile para criar nossa imagem do Docker e executar nosso aplicativo usando o Docker. Por meio deste exemplo simples, podemos entender facilmente como usar o Spring Boot e o Docker para criar e implantar microsserviços.