Gerenciamento de configuração: topologia baseada em push versus pull

Os sistemas de gerenciamento de configuração (CM) mais estabelecidos, como Puppet e Chef, usam uma abordagem baseada em pull: os clientes pesquisam periodicamente um mestre centralizado em busca de atualizações. Alguns deles também oferecem uma abordagem sem mestre (portanto, baseada em push), mas afirmam que 'não é para produção' (Saltstack) ou 'menos escalável' (Puppet). O único sistema que eu conheço que é baseado em push desde o início é o segundo classificado Ansible.

Qual é a vantagem específica de escalabilidade de um sistema baseado em pull? Por que é supostamente mais fácil adicionar mais pull-masters do que push-agents?

Por exemplo, agiletesting.blogspot.nl escreve:

em um sistema 'pull', os clientes entram em contato com o servidor independentemente um do outro, para que o sistema como um todo seja mais escalável que um sistema 'push'

Por outro lado, a Rackspace demonstra que eles podem lidar com sistemas de 15K com um modelo baseado em push.

infastructures.org escreve:

Juramos por uma metodologia pull para manutenção de infra-estruturas, usando uma ferramenta como SUP, CVSup, um servidor rsync ou cfengine. Em vez de enviar as alterações aos clientes, cada máquina cliente individual precisa ser responsável por pesquisar o servidor gold na inicialização e, periodicamente, posteriormente, para manter seu próprio nível de rotação. Antes de adotar esse ponto de vista, desenvolvemos extensos scripts baseados em envio baseados em ssh, rsh, rcp e rdist. O problema que encontramos com os comandos r (ou ssh) foi o seguinte: Quando você executa um script baseado em comando r para fazer uma alteração nas máquinas de destino, é provável que, se você tiver mais de 30 hosts de destino, um deles desça a qualquer momento. Manter a lista de máquinas comissionadas se torna um pesadelo. Ao escrever o código para corrigir isso, você terminará com um código de invólucro elaborado para lidar com: tempos limite de hosts mortos; registrar e tentar novamente hosts mortos; bifurcar e executar tarefas paralelas para tentar atingir muitos hosts em um período de tempo razoável; e finalmente detectando e impedindo o uso de todos os soquetes TCP disponíveis na máquina de origem com todas as sessões rsh de saída. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. bifurcar e executar tarefas paralelas para tentar atingir muitos hosts em um período de tempo razoável; e, finalmente, detectando e impedindo o uso de todos os soquetes TCP disponíveis na máquina de origem com todas as sessões rsh de saída. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. bifurcar e executar tarefas paralelas para tentar atingir muitos hosts em um período de tempo razoável; e, finalmente, detectando e impedindo o uso de todos os soquetes TCP disponíveis na máquina de origem com todas as sessões rsh de saída. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. e, finalmente, detectando e impedindo o uso de todos os soquetes TCP disponíveis na máquina de origem com todas as sessões rsh de saída. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. e, finalmente, detectando e impedindo o uso de todos os soquetes TCP disponíveis na máquina de origem com todas as sessões rsh de saída. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. Você ainda tem o problema de inserir o que acabou de fazer nas imagens de instalação para que todos os novos hosts sejam instalados no futuro, além de repeti-lo para todos os hosts que morrem e precisam ser reconstruídos amanhã. Após o problema que enfrentamos para implementar a replicação baseada em comando-r, descobrimos que não vale a pena. Não planejamos gerenciar uma infraestrutura com comandos r novamente ou com qualquer outro mecanismo de envio nesse sentido. Eles não escalam tão bem quanto métodos baseados em pull. ou com qualquer outro mecanismo de envio para esse assunto. Eles não escalam tão bem quanto métodos baseados em pull. ou com qualquer outro mecanismo de envio para esse assunto. Eles não escalam tão bem quanto métodos baseados em pull.

Isso não é um problema de implementação em vez de um problema de arquitetura? Por que é mais difícil gravar um cliente push encadeado do que um servidor pull encadeado?

O problema com sistemas baseados em envio é que você precisa ter um modelo completo de toda a arquitetura no nó de envio central. Você não pode empurrar para uma máquina que você não conhece.

Obviamente, pode funcionar, mas é preciso muito trabalho para mantê-lo sincronizado.

Usando coisas como o Mcollective, você pode converter o Puppet e outros CMs em um sistema baseado em push. Geralmente, é trivial converter um sistema pull em um sistema push, mas nem sempre é fácil seguir o caminho inverso.

Há também a questão da política organizacional. Um sistema baseado em envio coloca todas as mãos de controle dos administradores centrais. Pode ser muito difícil gerenciar a complexidade dessa maneira. Penso que a questão da escala é um arenque vermelho, qualquer uma das escalas de abordagem se você apenas observar o número de clientes. De muitas maneiras, o push é mais fácil de escalar. No entanto, a configuração dinâmica implica mais ou menos que você tenha pelo menos uma versão pull do registro do cliente.

Por fim, trata-se de qual sistema corresponde ao fluxo de trabalho e à propriedade da sua organização. Como regra geral, os sistemas pull são mais flexíveis.

No caso de ser de interesse de qualquer pessoa, acho que, no mínimo, posso fornecer um relatório de experiência do usuário que tenha feito meu primeiro uso do recurso de envio imediato da Ansible no contexto do gerenciamento de patches de configurações de vários hosts de sistemas de missão crítica na nuvem da Amazônia. Para entender meus preconceitos ou preconceitos, devo explicar que tenho preferência pelo Ruby no nível de script de automação e configurei projetos para usar a configuração de fantoche de agente mestre por VPC de projeto no passado. Portanto, minha experiência esconde preconceitos passados, se houver algum.

Minha experiência recente foi muito favorável ao envio dinâmico para um estado de mudança de dezenas a muitas centenas de servidores que podem ser ampliados ou reduzidos, finalizados e atualizados. Na minha situação, um simples comando ad hoc do Ansible 1.7 era tudo o que eu precisava para fazer o patch. No entanto, tendo em vista a eficácia da configuração de um AnsibleController (em um t2.micro) por Vpc para esse fim, no futuro pretendo expandir a técnica para requisitos mais complexos.

Então, deixe-me voltar à pergunta feita neste tópico: prós e contras de uma mudança dinâmica.

As suposições do tipo de propriedade do servidor que eu alvejei foram:

• Não há suposição de que endereços IP ou nomes de host locais gerados pela Amazon sejam duradouros - eles podem ir e vir
• Todas as instâncias foram criadas a partir de imagens de máquina que já tinham a capacidade de tornar possível o acesso ssh a partir de um único usuário administrativo privilegiado
• Para individualizar servidores e potencialmente particioná-los em grupos, de acordo com a função ou com o estágio de desenvolvimento (por exemplo, teste ou prod), isso seria feito através do lançamento de tags específicas da Amazon com nomes convencionais acordados
• Que eu administraria os servidores Linux e Windows separadamente, com comandos ad hoc diferentes, portanto, simplesmente permitir logins específicos do Linux falhar ao entrar em contato com um servidor Windows era perfeitamente aceitável

Com essas condições em mente, a criação de uma imagem de máquina de um AnsibleController para cair em vários Vpcs e configurar (com credenciais) in situ nas contas de servidor existentes é muito simples. Automatizado em cada instância criada a partir da imagem é

1. Uma tarefa cron para enviar o patch para servidores em execução em intervalos regulares, para que o estado necessário seja acessado continuamente em intervalos
2. Uma maneira de calcular o inventário Ansible a cada intervalo.

O segundo item pode ser feito relativamente sofisticado, se necessário (através da estrutura Info do inventário Ansible). Mas se a sofisticação não for necessária, aqui está um exemplo muito direto de um script para calcular todas as instâncias do Amazon EC2 a cada intervalo cron e direcionar os resultados em um arquivo de inventário apropriado (por exemplo, / etc / ansible / hosts)…

#!/bin/bash
# Assumes aws-cli/1.3.4 Python/2.6.9 Linux/3.4.73-64.112.amzn1.x86_64 or greater
# http://aws.amazon.com/releasenotes/8906204440930658
# To check yum list aws-cli
# Assumes that server is equipped with AWS keys and is able to access some or all
# instances in the account within it is running.
# Provide a list of host IPs each on a separate line
# If an argument is passed then treat it as the filename, whether local or absolute 
# path, to which the list is written

function list-of-ips {
    /usr/bin/aws ec2 describe-instances --filters '[ {"Name": "instance-state-code", "Values": [ "16" ] } ]' | grep -w PrivateIpAddress | awk  '{x=$2; gsub("\"","", x); gsub(",","", x); if(x && FNR!=1){print x;}}' | uniq
 }

if [ -n "$1" ]; then
   list-of-ips > "$1"
else
   list-of-ips
fi

A única ressalva para o caso de uso é que o comando patch deve ser idempotente. É recomendável fazer um pré-teste para garantir perfeitamente que isso seja satisfeito, como parte de garantir que o patch faça exatamente o que se destina.

Então, para resumir, ilustrei um caso de uso em que o envio dinâmico é eficaz em relação aos objetivos que estabeleci. É uma solução repetível (no sentido de ser encapsulado em uma imagem que pode ser lançada em várias contas e regiões). Na minha experiência até agora, a técnica de envio dinâmico é muito mais fácil de fornecer - e entrar em ação - do que as alternativas disponíveis nos conjuntos de ferramentas disponíveis para nós no momento.