Automatizando o processo de criação de host virtual

Question

Até recentemente, eu usava ferramentas como o Cpanel ou o Webmin para gerenciar hosts virtuais do Apache2. Recentemente, descobri como criá-los manualmente sob o diretório sites-available .

Eu posso fazer esse processo manualmente várias vezes, mas quando isso é feito manualmente, ele inclui muitos recursos de enfrentamento & colando, alterações repetitivas de strings (uma vez para o nome do arquivo e do domínio + tld dentro dele, e outras execuções como a2ensite (veja abaixo).

Eu agora procuro automatizar o processo, mas não tenho certeza qual é a melhor maneira de alterar domain + tld tanto dentro (no Vhost) quanto fora (no nome do arquivo e outras execuções)

Esta é a minha maneira de criar manualmente cada Vhost:

1. Copy a ready Vhost template file (I have such a file which I name 'd.t' and I clone it whenever I need to create a new Vhost):

    <VirtualHost *:80>
    DocumentRoot "/var/www/html/d.t"
    ServerName www.d.t
    <Directory "/var/www/html/d.t">
    Options +SymLinksIfOwnerMatch
    Require all granted
    </Directory>
    ServerAlias www.d.t
    </VirtualHost>

3. Search and replace "d.t", with domain+tld:

    Do in nano.

4. Replace filename (d.t) with domain+tld:

    mv /etc/apache2/sites-available/d.t /etc/apache2/sites-available/domain.tld

5. Enable domain.tld.conf & restart the Apache service:

    a2ensite domain.tld.conf && systemctl restart apache2.service

Isso pode parecer simples, mas quando eu manualmente faço esse algoritmo a partir de um arquivo manual, pode levar ainda mais tempo para reescrever cada exemplo como d.t no domínio relevante + tld.

Minha pergunta:

Estou procurando uma maneira de executar um script com estas ações: O script será realmente semelhante, mas neste script, d.t será substituído pelo nome de arquivo do script. Por exemplo, se o nome do arquivo do script for MyNewVhost.com , cada d.t de ocorrência dentro dela se tornará MyNewVhost.com .

Eu acho que algum trabalho variável pode servir a esse propósito, mas posso estar errado; Se assim for, uma maneira de dizer ao programa "Coloque o nome do arquivo em cada d.t" parece ser o que eu preciso.

Notas:

1. Acredito que uma resposta também poderia dar uma boa direção para pessoas com um problema semelhante nos blocos Nginx Server (Nginx Sblocks).

Answer 1

GNU make funciona bem

Você pode usar o GNU make ¹ , onde criar um novo host virtual é tão simples quanto executar make example.com

Curto e simples: um modelo estático

Primeiro, crie /etc/apache2/sites-available/Makefile contendo:

% :
    printf '%s\n'                         \
    '<VirtualHost *:80>'                  \
    '  DocumentRoot "/var/www/html/$@"'  \
    '  ServerName www.$@'                 \
    '  <Directory "/var/www/html/$@">'    \
    '    Options +SymLinksIfOwnerMatch'   \
    '    Require all granted'             \
    '  </Directory>'                      \
    '  ServerAlias www.$@'                \
    '</VirtualHost>'                      \
    > "$@"
    a2ensite "$@"
    systemctl restart apache2.service

Observe que cada linha após % : começa com uma guia, não com espaços. Observe também que a maioria disso é efetivamente seu arquivo de modelo, mas com d.t substituído por $@ .

Depois disso, você pode criar um novo host virtual chamado domain.tld :

cd /etc/apache2/sites-available
make domain.tld

Adicionando opções: vários modelos

Essa foi uma das maneiras mais simples de usar make . Para uma configuração um pouco mais complexa, suponha que você tenha dois (ou mais) modelos. Eu mostrarei um aqui, que chamei de basic.template , como um padrão:

<VirtualHost *:80>
  DocumentRoot "/var/www/html/$domain$"
  ServerName www.$domain$
  <Directory "/var/www/html/$domain$">
    Options +SymLinksIfOwnerMatch
    Require all granted
  </Directory>
  ServerAlias www.$domain$
</VirtualHost>

Você poderia então modificar (simplificar!) o seu Makefile :

% :
    sed 's/\$$domain\$$/$@/g' < "$<" > "$@"
    a2ensite "$@"
    systemctl restart apache2.service

.PHONY : all
all :
    @true

Aqui, a receita envolve o uso de sed para substituir uma variável do formulário $domain$ pelo nome de domínio pretendido. Além disso, adicionei uma meta PHONY chamada all , cujo uso logo se tornará aparente.

Para criar um host virtual agora, você terá que especificar o modelo which a ser usado. Para mim, parece melhor envolver isso em um script.

#!/bin/sh
# File update-makefile
# Call as:
#    ./update-makefile domain.tld basic.template
sed '/^all :/s/$/ '"$1"'/' < Makefile > Makefile.new
printf '%s\n' "$1 : $2" >> Makefile.new
mv Makefile.new Makefile

Note que isto tem um passo adicional de adicionar ² o novo host virtual ao Makefile. Isso permite que make veja qual modelo domain.tld depende . Então você poderia fazer:

cd /etc/apache2/sites-available
./update-makefile domain.tld basic.template && make

Com essa configuração, o site todos será atualizado se o modelo correspondente tiver sido alterado.

É importante que all seja o primeiro alvo . Isso torna o padrão quando make é chamado sem argumentos. O script update-makefile adiciona o novo domínio como uma dependência de all , portanto make irá recriá-lo se ficar desatualizado em relação à sua própria dependência, o arquivo de modelo.

¹ make é uma ferramenta que é usada para criar arquivos de destino de um conjunto de receitas e dependências que estão documentados em Makefile . Na sintaxe do GNU,

% :
    # do stuff

é uma regra padrão . Afirma que um arquivo com qualquer nome ( % ) pode ser criado como um destino e que não possui dependências. O # do stuff é a receita (qualquer script de shell), recuado por uma guia. Existem variáveis que você pode usar para se referir ao nome do destino ( $@ ), à primeira dependência ( $< ) ou a todas as dependências ( $^ ), entre outras. Para mais informações, consulte Wikipedia .

Seu sistema pode não ter make instalado. Nesse caso, você teria que instalá-lo por conta própria. Além disso, alguns sistemas usam uma variante BSD de make . Os conceitos são os mesmos, mas a sintaxe das regras é um pouco diferente das versões GNU.

² Certifique-se de usar >> para acrescentar ao invés de > para sobrescrever!

    

Answer 2

Parabéns, você está dando os primeiros passos para o gerenciamento de configurações!

Existem muitos resultados possíveis aqui, mas, na raiz, você cria um modelo de um snippet de configuração e cria instâncias desse modelo.

Você está correto, pois algumas variáveis em seu modelo podem atender à sua necessidade; é apenas uma questão de escolher alguma linguagem de programação (até mesmo shell simples) para conduzir o preenchimento do modelo com os valores necessários. A resposta de Fox usando o Make é um belo exemplo; e você poderia alterá-lo declarando todos os sites posteriormente no Makefile para reconstruir todos eles quando quiser atualizar o modelo.

Isso é no final simples do gerenciamento de configuração (mantenha seu script que preenche o modelo com variáveis, caso você queira atualizar muitas configurações mais tarde).

Em direção a mais complexidade, estão as ferramentas de gerenciamento de configuração, como Puppet, Chef, Cfengine, Salt, & mais.

Aqui está um off-line exemplo de uso do Puppet, com o módulo PuppetLabs Apache, e preenchê-lo com dados do Hiera (um conjunto estruturado de seus valores variáveis).

    

Answer 3

Você pode usar ansible , ele utiliza Jinja2 para criar modelos, e isso dá a você a possibilidade de automatizar muitas outras coisas também.