Implementați și gestionați în siguranță containerele LXC pe Ubuntu 14.04

• preparate
• Configurare sistem de operare
• Reţea
• Acces SSH
• Setari aditionale
• Port forwarding
• Containere separate

Containerele LXC (containere Linux) sunt o caracteristică a sistemului de operare în Linux care poate fi utilizată pentru a rula mai multe sisteme Linux izolate pe o singură gazdă.

Aceste instrucțiuni vă vor parcurge pașii de bază ai configurației serverului pentru găzduirea containerelor Linux izolate. Vom configura următoarele caracteristici:

• Containere LXC cu Ubuntu 14.
• Setările rețelei Linux și redirecționarea porturilor pentru containere.
• Transmitere SSH pentru administrarea containerului la fel de simplă ssh box1@example.comșissh box2@example.com
• Configurația proxy Nginx pentru accesarea site-urilor web din containere (după nume gazdă).
• Îmbunătățiri suplimentare de securitate pentru gestionarea corectă a serverului.

Acest ghid presupune că:

• Aveți un cont la Vultr.com .
• Știi cum să configurezi o mașină virtuală cu un ISO personalizat.
• Știi cum să folosești cheile SSH și ai generat deja chei publice și private.

La sfârșitul tutorialului vom primi două containere virtuale care vor avea acces la internet, dar care nu se pot juca unii pe alții. De asemenea, vom configura redirecționarea porturilor de example.comla containere. Vom implementa panoul de configurare și de gestionare securizat cu ajutorul instrumentelor din pachetul Proxmox.

preparate

Vom folosi Proxmox numai pentru gestionarea containerelor LXC. În general, acceptă și KVM, dar virtualizarea cuibărită este interzisă pe Vultr. Înainte de a începe, un Proxmox ISO ar trebui descărcat de pe site-ul oficial. Vom folosi Proxmox VE 5.0 ISO Installer. Instalați sistemul de operare din imagine cu setări implicite și reporniți mașina virtuală. De asemenea, puteți instala manual proxmox din surse, dar acest lucru nu este necesar în majoritatea cazurilor (urmați instrucțiunile de aici ).

Configurare sistem de operare

Conectați-vă la gazdă prin SSH, actualizați lista de șabloane proxmox și descărcați un șablon adecvat pentru containere.

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

Acum, trebuie să creăm un container linux cu interfață de rețea conectată la un pod linux. Deschideți /etc/network/interfacesși adăugați următoarele rânduri:

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

După repornirea sistemului, puteți crea un nou container din Ubuntu 14.04șablon.

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

Puteți verifica containerul folosind pct list, porniți containerul # 200 cu pct start 200și introduceți shell-ul cu pct enter 200. Puteți verifica, de asemenea, setările și adresele de rețea ip addr.

Reţea

Pentru a furniza conexiune la internet în interiorul containerului dvs., trebuie să activăm NAT. Următoarele vor permite redirecționarea traficului din container către internet cu ajutorul tehnologiei NAT. vmbr0Podul este conectat la interfața externă , iar vmbr1podul este conectat la containerele.

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

Introduceți containerul cu pct enter 200și configurați serverul web din interior.

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

Acum, trebuie să configuram Nginx pe serverul dvs. pentru a oferi site-uri web proxy în containere.

apt-get update
apt-get install nginx

Creați un nou fișier de configurare /etc/nginx/sites-available/box200cu următorul conținut:

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/;
    }
}

Nginx va proxy acum fiecare solicitare HTTP pentru server200.example.comserverul dvs. către container cu IP 10.100.0.200. Activați această configurație.

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

Acces SSH

Dacă doriți să oferiți un acces ușor la cutiile de nisip, trebuie să transmiteți sesiuni SSH în containere. Pentru a face acest lucru, creați un utilizator nou pe serverul dvs. root. Nu uitați să introduceți o parolă, alți parametri nu sunt necesari.

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

Copiați această cheie SSH și introduceți containerul pentru a adăuga cheia.

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

Pe serverul dvs., adăugați următoarea linie la .ssh/authorized_keysfișier.

command="ssh root@10.100.0.200",no-X11-forwarding,no-agent-forwarding,no-port-forwarding <YOUR SSH KEY>

Nu uitați să schimbați <YOUR SSH KEY>cheia publică de domiciliu. În mod alternativ, puteți rula următoarele din linia de comandă.

echo 'command="ssh root@10.100.0.200",no-X11-forwarding,no-agent-forwarding,no-port-forwarding <YOUR SSH KEY>' >> .ssh/authorized_keys

Apoi, vă puteți conecta la cutia dvs. de nisip cu ssh.

`ssh box200@<your_server_IP>`

Setari aditionale

Este timpul să implementăm mai multe îmbunătățiri de securitate. În primul rând, vrem să schimbăm portul SSH implicit. Apoi vrem să ne protejăm pagina de gestionare Proxmox cu autentificare HTTP de bază.

nano /etc/ssh/sshd_config

Dezacord și schimbă linia

#Port 22 

la

Port 24000 

Reporniți ssh.

service ssh restart

Reconectați-vă la ssh cu noul port.

ssh root@<your_IP> -p 24000

Setați o parolă Proxmox.

Creați fișier /etc/default/pveproxy.

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

Reporniți pveproxypentru ca modificările să aibă efect.

/etc/init.d/pveproxy restart

Configurați nginx (dacă nu ați făcut-o până acum).

apt-get install nginx
service nginx restart

Creați o configurație implicită în /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; }
}

Obțineți un certificat SSL valid și actualizați configurația nginx. De exemplu, acesta poate fi realizat cu ajutorul certificboxului și al cifrelor. Pentru mai multe informații, faceți clic aici .

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

Acum, configurația dvs. nginx ar trebui să arate așa (sau o puteți modifica manual după). Nu uitați să dezcomentați liniile ssl, auth și locație.

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
}

Creați un /etc/htpasswdfișier utilizând generatorul Htpasswd .

nano /etc/nginx/htpasswd

Reporniți Nginx

service nginx restart

Acum puteți vedea consola de administrare pornită https://example.comdupă autentificarea de bază.

Port forwarding

Containerele sunt acum disponibile prin cereri HTTP și SSH. Acum, putem configura redirecționarea porturilor de pe serverul extern către containere. De exemplu, pentru mapare example.com:8080să 10.100.0.200:3000introduceți următoarele.

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

Puteți vedea regulile actuale.

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

Puteți șterge, de asemenea, o regulă după număr.

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

Containere separate

Acum putem accesa un container din altul.

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

Dacă doriți să restricționați accesul de la containerul 250 la 200, trebuie să conectați fiecare container la un pod personal și să dezactivați redirecționarea între poduri.

1. Ștergeți containerele existente.

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

2. Schimbați conținutul /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 sistemul

4. Activați redirecționarea

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

   Pentru a face aceste modificări permanente, puteți edita /etc/sysctl.conffișierul și găsiți următorul text.

   #net.ipv4.ip_forward=1
   

   Dezacordează-l.

   net.ipv4.ip_forward=1
   

   Puteți, de asemenea, sysctl -psă alergați pentru ca modificările să aibă efect imediat.

5. Creați containere.

   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. Porniți recipientele cu pct start 200și pct start 250.

7. Spălați iptablesregulile.

   iptables -F
   

8. Activați NAT.

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

   vmbr0 este podul care include interfața externă.

9. Permiteți redirecționarea de la interfața externă.

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

10. Permiteți redirecționarea de pe containere către 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. Aruncați cealaltă înaintare.

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

Acum, verificați că 10.100.1.200pot face ping, 8.8.8.8dar nu pot face ping 10.100.2.250și că 10.100.2.250pot face ping, 8.8.8.8dar nu pot face ping 10.100.1.200.

Ordinea comenzilor legate de iptables este importantă. Cel mai bun mod de a-ți folosi regulile este să folosești iptables-persistent. Acest pachet vă ajută să salvați regulile iptables la fișierele /etc/iptables/rules.v4și /etc/iptables/rules.v6și le poate încărca în mod automat după repornirea sistemului. Instalați-l doar cu următoarele.

apt-get install iptables-persistent

Selectați YEScând vi se solicită.