Implante e gerencie com segurança contêineres LXC no Ubuntu 14.04

• Preparações
• Configuração do SO
• Rede
• Acesso SSH
• Configurações adicionais
• Encaminhamento de porta
• Recipientes separados

Os contêineres LXC (contêineres do Linux) são um recurso do sistema operacional no Linux que pode ser usado para executar vários sistemas Linux isolados em um único host.

Essas instruções orientarão você nas etapas básicas da configuração do servidor para hospedagem isolada de contêineres Linux. Vamos configurar os seguintes recursos:

• Contêineres LXC com o Ubuntu 14.
• Configurações de rede Linux e encaminhamento de porta para contêineres.
• Encaminhamento SSH para administração recipiente tão simples como ssh [email protected]essh [email protected]
• Configuração do proxy Nginx para acessar sites dentro de contêineres (por nome do host).
• Melhorias de segurança adicionais para gerenciamento adequado do servidor.

Este guia pressupõe que:

• Você tem uma conta no Vultr.com .
• Você sabe como configurar uma máquina virtual com um ISO personalizado.
• Você sabe como usar chaves SSH e já gerou chaves públicas e privadas.

No final do tutorial, obteremos dois contêineres virtuais que terão acesso à Internet, mas não poderão executar ping um ao outro. Também configuraremos o encaminhamento de porta example.compara os contêineres. Implementaremos o painel de configuração e gerenciamento seguro com a ajuda de ferramentas do pacote Proxmox.

Preparações

Usaremos o Proxmox apenas para o gerenciamento de contêineres LXC. Geralmente, ele também suporta KVM, mas a virtualização aninhada é proibida no Vultr. Antes do início, um Proxmox ISO deve ser baixado do site oficial. Nós vamos usar o Proxmox VE 5.0 ISO Installer. Instale o sistema operacional a partir da imagem com as configurações padrão e reinicie a máquina virtual. Além disso, você pode instalar manualmente o proxmox a partir de fontes, mas isso não é necessário na maioria dos casos (siga as instruções aqui ).

Configuração do SO

Conecte-se ao seu host por SSH, atualize a lista de modelos proxmox e faça o download de um modelo adequado para contêineres.

apt-get update
pveam update
pveam available
pveam download local ubuntu-14.04-standard_14.04-1_amd64.tar.gz

Agora, precisamos criar um contêiner linux com a interface de rede conectada a uma ponte linux. Abra /etc/network/interfacese acrescente as seguintes linhas:

auto vmbr1
iface vmbr1 inet static
    address  10.100.0.1
    netmask  255.255.255.0
    bridge_ports none
    bridge_stp off
    bridge_fd 0

Após a reinicialização do sistema, você pode criar um novo contêiner a partir do Ubuntu 14.04modelo.

pct create 200 /var/lib/vz/template/cache/ubuntu-14.04-standard_14.04-1_amd64.tar.gz -storage local-lvm -net0 name=eth0,bridge=vmbr1,ip=10.100.0.200/24,gw=10.100.0.1

Você pode verificar seu contêiner usando pct list, inicie o contêiner nº 200 pct start 200e insira seu shell com pct enter 200. Você também pode verificar as configurações e endereços de rede com ip addr.

Rede

Para fornecer conexão à Internet dentro do seu contêiner, precisamos ativar NAT. O seguinte permitirá que o tráfego seja encaminhado do contêiner para a Internet com a ajuda da tecnologia NAT. A vmbr0ponte está conectada à interface externa e a vmbr1ponte está conectada aos contêineres.

sysctl -w net.ipv4.ip_forward=1
iptables --table nat --append POSTROUTING --out-interface vmbr0 -j MASQUERADE
iptables --append FORWARD --in-interface vmbr1 -j ACCEPT

Entre no contêiner pct enter 200e configure o servidor da web.

apt-get update
apt-get install nginx
service nginx start
exit

Agora, precisamos configurar o Nginx no seu servidor para proxy de sites em contêineres.

apt-get update
apt-get install nginx

Crie um novo arquivo de configuração /etc/nginx/sites-available/box200com o seguinte conteúdo:

server {
    listen 80;
    server_name server200.example.com;

    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $remote_addr;

    location / {
        proxy_pass http://10.100.0.200/;
    }
}

O Nginx agora fará proxy de cada solicitação HTTP server200.example.comdo servidor para o contêiner com IP 10.100.0.200. Ative esta configuração.

ln -s /etc/nginx/sites-available/box200 /etc/nginx/sites-enabled/
service nginx restart

Acesso SSH

Se você deseja fornecer acesso fácil às caixas de proteção, é necessário encaminhar as sessões SSH para os contêineres. Para fazer isso, crie um novo usuário no seu servidor raiz. Não se esqueça de inserir uma senha, outros parâmetros não são necessários.

adduser box200
su - box200
ssh-keygen
cat .ssh/id_rsa.pub
exit

Copie essa chave SSH e insira o contêiner para anexar a chave.

pct enter 200
mkdir .ssh
nano .ssh/authorized_keys
exit

No seu servidor, adicione a seguinte linha ao .ssh/authorized_keysarquivo.

command="ssh [email protected]",no-X11-forwarding,no-agent-forwarding,no-port-forwarding <YOUR SSH KEY>

Não esqueça de mudar <YOUR SSH KEY>para sua chave pública doméstica. Como alternativa, você pode executar o seguinte na linha de comando.

echo 'command="ssh [email protected]",no-X11-forwarding,no-agent-forwarding,no-port-forwarding <YOUR SSH KEY>' >> .ssh/authorized_keys

Em seguida, você pode se conectar à sua caixa de areia com o ssh.

`ssh box200@<your_server_IP>`

Configurações adicionais

É hora de implementar várias melhorias de segurança. Primeiro, queremos alterar a porta SSH padrão. Em seguida, queremos proteger nossa página de gerenciamento do Proxmox com autenticação HTTP básica.

nano /etc/ssh/sshd_config

Remova o comentário e altere a linha

#Port 22 

para

Port 24000 

Reinicie o ssh.

service ssh restart

Reconecte-se ao ssh com a nova porta.

ssh root@<your_IP> -p 24000

Defina uma senha do Proxmox.

Crie arquivo /etc/default/pveproxy.

ALLOW_FROM="127.0.0.1"
DENY_FROM="all"
POLICY="allow"

Reinicie pveproxypara que as alterações tenham efeito.

/etc/init.d/pveproxy restart

Configure o nginx (se você não tiver feito isso antes).

apt-get install nginx
service nginx restart

Crie uma configuração padrão no /etc/nginx/site-available/default.

server {
        listen          80;
        server_name     example.com;
        rewrite         ^ https://$hostname.example.com$request_uri? permanent;
}
server {
        listen                   443 ssl;
        server_name              example.com;
        #auth_basic              "Restricted";
        #auth_basic_user_file    htpasswd;
        #location / { proxy_pass https://127.0.0.1:8006; }
}

Obtenha um certificado SSL válido e atualize sua configuração nginx. Por exemplo, isso pode ser feito com a ajuda de certbox e letsencrypt. Para mais informações, clique aqui .

wget https://dl.eff.org/certbot-auto
chmod +x certbot-auto
./certbot-auto --nginx

Agora, sua configuração do nginx deve ficar assim (ou você pode alterá-la manualmente depois). Não se esqueça de descomentar ssl, auth e linhas de localização.

server {
    listen          80;
    server_name     example.com;
    rewrite         ^ https://$hostname.example.com$request_uri? permanent;
}

server {
        listen                  443 ssl;
        server_name             example.com;
        ssl on;
        auth_basic              "Restricted";
        auth_basic_user_file    htpasswd;
        location / { proxy_pass https://127.0.0.1:8006; }        

        ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem; # managed by Certbot
        ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem; # managed by Certbot
}

Crie um /etc/htpasswdarquivo usando o gerador Htpasswd .

nano /etc/nginx/htpasswd

Reinicie o Nginx

service nginx restart

Agora você pode visualizar o console de gerenciamento https://example.comapós a autenticação básica.

Encaminhamento de porta

Os contêineres estão agora disponíveis por solicitações HTTP e SSH. Agora, podemos configurar o encaminhamento de porta do servidor externo para os contêineres. Por exemplo, para mapear example.com:8080para 10.100.0.200:3000inserir o seguinte.

iptables -t nat -A PREROUTING -i vmbr0 -p tcp --dport 8080 -j DNAT --to 10.100.0.200:3000

Você pode ver as regras atuais.

`iptables -t nat -v -L PREROUTING -n --line-number`

Você também pode excluir uma regra pelo número com o seguinte.

`iptables -t nat -D PREROUTING <#>`.

Recipientes separados

Agora podemos acessar um contêiner de outro.

pct create 250 /var/lib/vz/template/cache/ubuntu-14.04-standard_14.04-1_amd64.tar.gz -storage local-lvm -net0 name=eth0,bridge=vmbr1,ip=10.100.0.250/24,gw=10.100.0.1
pct start 250
pct enter 250
ping 10.100.0.200

Se você deseja restringir o acesso do contêiner 250 a 200, é necessário conectar cada contêiner a uma ponte pessoal e desativar o encaminhamento entre pontes.

1. Exclua contêineres existentes.

   pct stop 200
   pct stop 250
   pct destroy 200
   pct destroy 250
   

2. Mude o conteúdo de /etc/network/interfaces.

   auto vmbr1
   iface vmbr1 inet static
       address  10.100.1.1
       netmask  255.255.255.0
       bridge_ports none
       bridge_stp off
       bridge_fd 0
   
   auto vmbr2
   iface vmbr2 inet static
       address  10.100.2.1
       netmask  255.255.255.0
       bridge_ports none
       bridge_stp off
       bridge_fd 0
   

3. reboot o sistema

4. Ativar encaminhamento

   `sysctl -w net.ipv4.ip_forward=1`
   

   Para tornar essas alterações permanentes, você pode editar o /etc/sysctl.confarquivo e encontrar o texto a seguir.

   #net.ipv4.ip_forward=1
   

   Remova o comentário.

   net.ipv4.ip_forward=1
   

   Você também pode executar sysctl -ppara que as alterações entrem em vigor imediatamente.

5. Crie contêineres.

   pct create 200 /var/lib/vz/template/cache/ubuntu-14.04-standard_14.04-1_amd64.tar.gz -storage local-lvm -net0 name=eth0,bridge=vmbr1,ip=10.100.1.200/24,gw=10.100.1.1
   pct create 250 /var/lib/vz/template/cache/ubuntu-14.04-standard_14.04-1_amd64.tar.gz -storage local-lvm -net0 name=eth0,bridge=vmbr2,ip=10.100.2.250/24,gw=10.100.2.1
   

6. Inicie os contêineres com pct start 200e pct start 250.

7. Liberar as iptablesregras.

   iptables -F
   

8. Habilite o NAT.

   iptables --table nat --append POSTROUTING --out-interface vmbr0 -j MASQUERADE
   

   vmbr0 é a ponte que inclui interface externa.

9. Permitir o encaminhamento a partir da interface externa.

   iptables --append FORWARD --in-interface vmbr0 -j ACCEPT
   

10. Permitir o encaminhamento dos contêineres para a Internet.

    iptables -A FORWARD -i vmbr1 -o vmbr0 -s 10.100.1.0/24 -j ACCEPT
    iptables -A FORWARD -i vmbr2 -o vmbr0 -s 10.100.2.0/24 -j ACCEPT
    

11. Solte o outro encaminhamento.

    iptables -A FORWARD -i vmbr1 -j DROP
    iptables -A FORWARD -i vmbr2 -j DROP
    

Agora, verifique se é 10.100.1.200possível executar ping 8.8.8.8mas não pode executar ping 10.100.2.250e se 10.100.2.250pode executar ping 8.8.8.8mas não pode executar ping 10.100.1.200.

A ordem dos comandos relacionados ao iptables é importante. A melhor maneira de operar suas regras é usar iptables-persistent. Este pacote ajuda a salvar as regras do iptables nos arquivos /etc/iptables/rules.v4e /etc/iptables/rules.v6pode carregá-las automaticamente após a reinicialização do sistema. Basta instalá-lo com o seguinte.

apt-get install iptables-persistent

Selecione YESquando solicitado.