Amministratore Linux - Guida rapida

Unico tra le distribuzioni Linux di classe business, CentOS rimane fedele alla natura open source su cui è stato fondato Linux. Il primo kernel Linux è stato sviluppato da uno studente universitario dell'Università di Helsinki (Linus Torvalds) e combinato con le utilità GNU fondate e promosse da Richard Stallman. CentOS ha una licenza open source comprovata che può alimentare il mondo degli affari di oggi.

CentOS è diventata rapidamente una delle piattaforme server più prolifiche al mondo. Qualsiasi amministratore Linux, quando cerca lavoro, è obbligato a trovare le parole: "CentOS Linux Experience Preferred". Dalle startup ai titani tecnologici di Fortune 10 , CentOS si è collocata tra i livelli più alti dei sistemi operativi per server in tutto il mondo.

Ciò che distingue CentOS dalle altre distribuzioni Linux è un'ottima combinazione di:

Licenza open source
Base di utenti dedicata di professionisti Linux
Buon supporto hardware
Stabilità e affidabilità solide come una roccia
Concentrati sulla sicurezza e sugli aggiornamenti
Stretta aderenza agli standard di packaging del software necessari in un ambiente aziendale

Prima di iniziare le lezioni, si presume che i lettori abbiano una conoscenza di base di Linux e dei fondamenti di amministrazione come:

Qual è l'utente root?
Il potere dell'utente root
Concetto di base di gruppi di sicurezza e utenti
Esperienza nell'utilizzo di un emulatore di terminale Linux
Concetti fondamentali di rete
Comprensione fondamentale dei linguaggi di programmazione interpretati (Perl, Python, Ruby)
Protocolli di rete come HTTP, LDAP, FTP, IMAP, SMTP
Core che compongono il sistema operativo di un computer: file system, driver e kerne

Prima di apprendere gli strumenti di un amministratore Linux CentOS, è importante notare la filosofia alla base della riga di comando dell'amministrazione Linux.

Linux è stato progettato sulla base della filosofia Unix di "strumenti piccoli e precisi concatenati insieme semplificando compiti più grandi". Linux, alla sua radice, non ha grandi applicazioni monouso per un uso specifico per la maggior parte del tempo. Invece, ci sono centinaia di utilità di base che, se combinate, offrono una grande potenza per svolgere grandi compiti con efficienza.

Esempi della filosofia Linux

Ad esempio, se un amministratore desidera un elenco di tutti gli utenti correnti su un sistema, i seguenti comandi concatenati possono essere utilizzati per ottenere un elenco di tutti gli utenti del sistema. All'esecuzione del comando, gli utenti presenti nel sistema vengono elencati in ordine alfabetico.

[root@centosLocal centos]# cut /etc/passwd -d":" -f1 | sort 
abrt 
adm 
avahi 
bin 
centos 
chrony 
colord 
daemon 
dbus

È facile esportare questo elenco in un file di testo utilizzando il seguente comando.

[root@localhost /]# cut /etc/passwd -d ":" -f1 > system_users.txt        
[root@localhost /]# cat ./system_users.txt | sort | wc –l 
40       
[root@localhost /]#

È anche possibile confrontare l'elenco utenti con un'esportazione in una data successiva.

[root@centosLocal centos]#  cut /etc/passwd -d ":" -f1 > system_users002.txt && 
   cat system_users002.txt | sort | wc -l 
41 
[root@centosLocal centos]# diff ./system_users.txt ./system_users002.txt  
evilBackdoor [root@centosLocal centos]#

Con questo approccio di piccoli strumenti concatenati per svolgere attività più grandi, è più semplice creare uno script che esegua questi comandi, piuttosto che inviare automaticamente i risultati a intervalli di tempo regolari.

I comandi di base che ogni amministratore Linux dovrebbe conoscere sono:

vim
grep
più o meno
tail
head
wc
sort
uniq
tee
cat
cut
sed
tr
paste

Nel mondo Linux, gli amministratori utilizzano filteringcomandi ogni giorno per analizzare i log, filtrare l'output dei comandi ed eseguire azioni con script di shell interattivi. Come accennato, il potere di questi comandi risiede nella loro capacità di modificarsi a vicenda attraverso un processo chiamatopiping.

Il comando seguente mostra quante parole iniziano con la lettera a dal dizionario utente principale di CentOS.

[root@centosLocal ~]# egrep '^a.*$' /usr/share/dict/words | wc -l 
25192 
[root@centosLocal ~]#

Per introdurre le autorizzazioni quando si applicano sia alle directory che ai file in CentOS Linux, diamo un'occhiata al seguente output del comando.

[centos@centosLocal etc]$ ls -ld /etc/yum* 
drwxr-xr-x. 6 root root 100 Dec  5 06:59 /etc/yum 
-rw-r--r--. 1 root root 970 Nov 15 08:30 /etc/yum.conf 
drwxr-xr-x. 2 root root 187 Nov 15 08:30 /etc/yum.repos.d

Note - I tre tipi di oggetti principali che vedrai sono

"-" - un trattino per file semplice
"d" - per una directory
"l" - per un collegamento simbolico

Ci concentreremo sui tre blocchi di output per ogni directory e file -

drwxr-xr-x: root: root
-rw-r - r--: root: root
drwxr-xr-x: root: root

Ora analizziamolo, per capire meglio queste righe -

d	Significa che il tipo di oggetto è una directory
rwx	Indica le autorizzazioni di directory applicate al proprietario
rx	Indica le autorizzazioni di directory applicate al gruppo
rx	Indica i permessi di directory applicati al mondo
radice	La prima istanza, indica il proprietario della directory
radice	La seconda istanza, indica il gruppo a cui vengono applicate le autorizzazioni di gruppo

Comprendere la differenza tra proprietario , gruppo e mondo è importante. Non capirlo può avere grandi conseguenze sui server che ospitano servizi su Internet.

Prima di fornire un esempio del mondo reale, prima di tutto comprendiamo i permessi che si applicano a directory e file .

Si prega di dare un'occhiata alla seguente tabella, quindi continuare con le istruzioni.

Octal	Simbolico	Perm.	Directory
1	X	Eseguire	Entra nella directory e accedi ai file
2	w	Scrivi	Elimina o modifica i file in una directory
4	r	Leggere	Elenca i file all'interno della directory

Note- Quando i file devono essere accessibili per la lettura in una directory, è comune applicare i permessi di lettura ed esecuzione . In caso contrario, gli utenti avranno difficoltà a lavorare con i file. Lasciare la scrittura disabilitata assicurerà che i file non possano essere: rinominati, eliminati, copiati o che le autorizzazioni siano modificate.

Applicazione delle autorizzazioni a directory e file

Quando si applicano le autorizzazioni, ci sono due concetti da comprendere:

Autorizzazioni simboliche
Autorizzazioni ottali

In sostanza, ognuno è lo stesso ma un modo diverso di fare riferimento e assegnare i permessi ai file. Per una guida rapida, si prega di studiare e fare riferimento alla seguente tabella:

	Leggere	Scrivi	Eseguire
Octal	4	2	1
Symbolic	r	w	X

Quando si assegnano le autorizzazioni utilizzando il octalutilizzare un numero di 3 byte come: 760. Il numero 760 si traduce in: Owner: rwx; Gruppo: rw; Altro (o mondo) nessun permesso.

Un altro scenario: 733 si tradurrebbe in: Owner: rwx; Gruppo: wx; Altro: wx.

C'è uno svantaggio nelle autorizzazioni che utilizzano il metodo Octal. I set di autorizzazioni esistenti non possono essere modificati. È possibile solo riassegnare l'intero set di autorizzazioni di un oggetto.

Ora potresti chiederti, cosa c'è di sbagliato nel riassegnare sempre le autorizzazioni? Immagina una grande struttura di directory, ad esempio / var / www / su un server web di produzione. Vogliamo rimuovere ricorsivamente il bit w o write su tutte le directory per Altro. Quindi, costringendolo ad essere aggiunto in modo proattivo solo quando necessario per le misure di sicurezza. Se riassegniamo l'intero set di autorizzazioni, rimuoviamo tutte le altre autorizzazioni personalizzate assegnate a ogni sottodirectory.

Quindi, causerà un problema sia per l'amministratore che per l'utente del sistema. Ad un certo punto, una persona (o più persone) avrebbe bisogno di riassegnare tutte le autorizzazioni personalizzate che sono state cancellate riassegnando l'intero set di autorizzazioni per ogni directory e oggetto.

In questo caso, vorremmo utilizzare il metodo simbolico per modificare i permessi -

chmod -R o-w /var/www/

Il comando precedente non "sovrascrive le autorizzazioni" ma modifica i set di autorizzazioni correnti. Quindi abituati a utilizzare le migliori pratiche

Ottale solo per assegnare le autorizzazioni
Simbolico per modificare i set di autorizzazioni

È importante che un amministratore CentOS sia competente con le autorizzazioni ottali e simboliche poiché le autorizzazioni sono importanti per l'integrità dei dati e dell'intero sistema operativo. Se le autorizzazioni non sono corrette, il risultato finale saranno sia dati sensibili che l'intero sistema operativo sarà compromesso.

Detto questo, diamo un'occhiata ad alcuni comandi per modificare le autorizzazioni e il proprietario / i membri dell'oggetto:

chmod
chown
chgrp
umask

chmod: Modifica i bit di autorizzazione della modalità file

Comando	Azione
-c	Come dettagliato, ma riporterà solo le modifiche apportate
-v	Dettagliato, restituisce la diagnostica per ogni richiesta effettuata
-R	Ricorsivamente applica l'operazione su file e directory

chmod ci permetterà di cambiare i permessi di directory e file usando set di permessi ottali o simbolici . Lo useremo per modificare le nostre directory di assegnazione e caricamento.

chown: cambia il proprietario del file e il gruppo

Comando	Azione
-c	Come dettagliato, ma riporterà solo le modifiche apportate
-v	Dettagliato, restituisce la diagnostica per ogni richiesta effettuata
-R	Ricorsivamente applica l'operazione su file e directory

chown può modificare sia la proprietà dell'utente che il gruppo di oggetti. Tuttavia, a meno che non sia necessario modificarli entrambi allo stesso tempo, l'uso di chgrp viene solitamente utilizzato per i gruppi.

chgrp: modifica la proprietà del gruppo di file o directory

Comando	Azione
-c	Come dettagliato, ma riporterà solo le modifiche
-v	Dettagliato, restituisce la diagnostica per ogni richiesta effettuata
-R	Ricorsivamente, applica le operazioni su file e directory

chgrp cambierà il proprietario del gruppo in quello fornito.

Pratica del mondo reale

Cambiamo tutte le assegnazioni delle sottodirectory in / var / www / students / in modo che il gruppo proprietario sia il gruppo degli studenti . Quindi assegna la radice degli studenti al gruppo dei professori. Successivamente, rendere il dottor Terry Thomas il proprietario della directory degli studenti , poiché è incaricato di essere a capo di tutte le università di informatica della scuola.

Come possiamo vedere, una volta creata, la directory rimane piuttosto grezza.

[root@centosLocal ~]# ls -ld /var/www/students/ 
drwxr-xr-x. 4 root root 40 Jan  9 22:03 /var/www/students/

[root@centosLocal ~]# ls -l /var/www/students/ 
total 0 
drwxr-xr-x. 2 root root 6 Jan  9 22:03 assignments 
drwxr-xr-x. 2 root root 6 Jan  9 22:03 uploads 

[root@centosLocal ~]#

In qualità di amministratori, non vogliamo mai dare le nostre credenziali di root a nessuno. Ma allo stesso tempo, dobbiamo consentire agli utenti di svolgere il proprio lavoro. Consentiamo quindi al Dr. Terry Thomas di assumere un maggiore controllo sulla struttura dei file e di limitare ciò che gli studenti possono fare.

[root@centosLocal ~]# chown -R drterryt:professors /var/www/students/ 
[root@centosLocal ~]# ls -ld /var/www/students/ 
drwxr-xr-x. 4 drterryt professors 40 Jan  9 22:03 /var/www/students/

[root@centosLocal ~]# ls -ls /var/www/students/ 
total 0 
0 drwxr-xr-x. 2 drterryt professors 6 Jan  9 22:03 assignments 
0 drwxr-xr-x. 2 drterryt professors 6 Jan  9 22:03 uploads

[root@centosLocal ~]#

Ora, ogni directory e sottodirectory ha un proprietario di drterryt e il gruppo proprietario è professors . Poiché la directory dei compiti consente agli studenti di consegnare il lavoro assegnato, togliamo la possibilità di elencare e modificare i file dal gruppo di studenti .

[root@centosLocal ~]# chgrp students /var/www/students/assignments/ && chmod 
736 /var/www/students/assignments/

[root@centosLocal assignments]# ls -ld /var/www/students/assignments/ 
drwx-wxrw-. 2 drterryt students 44 Jan  9 23:14 /var/www/students/assignments/

[root@centosLocal assignments]#

Gli studenti possono copiare i compiti nella directory dei compiti . Ma non possono elencare il contenuto della directory, copiare sui file correnti o modificare i file nella directory delle assegnazioni . Pertanto, consente solo agli studenti di inviare i compiti completati. Il filesystem CentOS fornirà un timbro con la data di quando gli incarichi vengono consegnati.

In qualità di proprietario della directory delle assegnazioni -

[drterryt@centosLocal assignments]$ whoami drterryt [drterryt@centosLocal assignments]$ ls -ld /var/www/students/assignment 
drwx-wxrw-. 2 drterryt students 44 Jan  9 23:14 /var/www/students/assignments/

[drterryt@centosLocal assignments]$ ls -l /var/www/students/assignments/ total 4 -rw-r--r--. 1 adama students 0 Jan 9 23:14 myassign.txt -rw-r--r--. 1 tammyr students 16 Jan 9 23:18 terryt.txt [drterryt@centosLocal assignments]$

Possiamo vedere, il proprietario della directory può elencare file, nonché modificare e rimuovere file.

Comando umask: fornisce le modalità predefinite per i permessi di file e directory man mano che vengono creati

umask è un comando importante che fornisce le modalità predefinite per i permessi di file e directory man mano che vengono creati.

I permessi di umask usano una logica unaria e negata.

Autorizzazione	Operazione
0	Leggi, scrivi, esegui
1	Leggere e scrivere
2	Leggi ed esegui
3	Sola lettura
4	Leggi ed esegui
5	Scrivi solo
6	Esegui solo
7	Nessun permesso

[adama@centosLocal umask_tests]$ ls -l ./ -rw-r--r--. 1 adama students 0 Jan 10 00:27 myDir -rw-r--r--. 1 adama students 0 Jan 10 00:27 myFile.txt [adama@centosLocal umask_tests]$ whoami 
adama

[adama@centosLocal umask_tests]$ umask 0022 [adama@centosLocal umask_tests]$

Ora, cambiamo l' umask per il nostro utente corrente e creiamo un nuovo file e una nuova directory.

[adama@centosLocal umask_tests]$ umask 077 [adama@centosLocal umask_tests]$ touch mynewfile.txt

[adama@centosLocal umask_tests]$ mkdir myNewDir [adama@centosLocal umask_tests]$ ls -l 
total 0 
-rw-r--r--. 1 adama students 0 Jan 10 00:27 myDir 
-rw-r--r--. 1 adama students 0 Jan 10 00:27 myFile.txt 
drwx------. 2 adama students 6 Jan 10 00:35 myNewDir 
-rw-------. 1 adama students 0 Jan 10 00:35 mynewfile.txt

Come possiamo vedere, i file appena creati sono un po 'più restrittivi di prima.

umask per gli utenti deve essere modificata in -

/etc/profile
~/bashrc

[root@centosLocal centos]# su adama 
[adama@centosLocal centos]$ umask 0022 [adama@centosLocal centos]$

Generally, the default umask in CentOS will be okay. When we run into trouble with a default of 0022, is usually when different departments belonging to different groups need to collaborate on projects.

This is where the role of a system administrator comes in, to balance the operations and design of the CentOS operating system.

When discussing user management, we have three important terms to understand −

Users
Groups
Permissions

We have already discussed in-depth permissions as applied to files and folders. In this chapter, let's discuss about users and groups.

CentOS Users

In CentOS, there are two types accounts −

System accounts − Used for a daemon or other piece of software.
Interactive accounts − Usually assigned to a user for accessing system resources.

The main difference between the two user types is −

System accounts are used by daemons to access files and directories. These will usually be disallowed from interactive login via shell or physical console login.
Interactive accounts are used by end-users to access computing resources from either a shell or physical console login.

With this basic understanding of users, let's now create a new user for Bob Jones in the Accounting Department. A new user is added with the adduser command.

Following are some adduser common switches −

Switch	Action
-c	Adds comment to the user account
-m	Creates user home directory in default location, if nonexistent
-g	Default group to assign the user
-n	Does not create a private group for the user, usually a group with username
-M	Does not create a home directory
-s	Default shell other than /bin/bash
-u	Specifies UID (otherwise assigned by the system)
-G	Additional groups to assign the user to

When creating a new user, use the -c, -m, -g, -n switches as follows −

[root@localhost Downloads]# useradd -c "Bob Jones  Accounting Dept Manager" 
-m -g accounting -n bjones

Now let's see if our new user has been created −

[root@localhost Downloads]# id bjones 
(bjones) gid = 1001(accounting) groups = 1001(accounting)

[root@localhost Downloads]# grep bjones /etc/passwd 
bjones:x:1001:1001:Bob Jones  Accounting Dept Manager:/home/bjones:/bin/bash

[root@localhost Downloads]#

Now we need to enable the new account using the passwd command −

[root@localhost Downloads]# passwd bjones 
Changing password for user bjones. 
New password:  
Retype new password:  
passwd: all authentication tokens updated successfully.

[root@localhost Downloads]#

The user account is not enabled allowing the user to log into the system.

Disabling User Accounts

There are several methods to disable accounts on a system. These range from editing the /etc/passwd file by hand. Or even using the passwd command with the -lswitch. Both of these methods have one big drawback: if the user has ssh access and uses an RSA key for authentication, they can still login using this method.

Now let’s use the chage command, changing the password expiry date to a previous date. Also, it may be good to make a note on the account as to why we disabled it.

[root@localhost Downloads]# chage -E 2005-10-01 bjones
 
[root@localhost Downloads]# usermod  -c "Disabled Account while Bob out of the country 
for five months" bjones

[root@localhost Downloads]# grep bjones /etc/passwd 
bjones:x:1001:1001:Disabled Account while Bob out of the country for four 
months:/home/bjones:/bin/bash

[root@localhost Downloads]#

Manage Groups

Managing groups in Linux makes it convenient for an administrator to combine the users within containers applying permission-sets applicable to all group members. For example, all users in Accounting may need access to the same files. Thus, we make an accounting group, adding Accounting users.

For the most part, anything requiring special permissions should be done in a group. This approach will usually save time over applying special permissions to just one user. Example, Sally is in-charge of reports and only Sally needs access to certain files for reporting. However, what if Sally is sick one day and Bob does reports? Or the need for reporting grows? When a group is made, an Administrator only needs to do it once. The add users is applied as needs change or expand.

Following are some common commands used for managing groups −

chgrp
groupadd
groups
usermod

chgrp − Changes the group ownership for a file or directory.

Let's make a directory for people in the accounting group to store files and create directories for files.

[root@localhost Downloads]# mkdir /home/accounting

[root@localhost Downloads]# ls -ld /home/accounting
drwxr-xr-x. 2 root root 6 Jan 13 10:18 /home/accounting

[root@localhost Downloads]#

Next, let's give group ownership to the accounting group.

[root@localhost Downloads]# chgrp -v  accounting /home/accounting/ 
changed group of ‘/home/accounting/’ from root to accounting

[root@localhost Downloads]# ls -ld /home/accounting/ 
drwxr-xr-x. 2 root accounting 6 Jan 13 10:18 /home/accounting/

[root@localhost Downloads]#

Now, everyone in the accounting group has read and execute permissions to /home/accounting. They will need write permissions as well.

[root@localhost Downloads]# chmod g+w /home/accounting/

[root@localhost Downloads]# ls -ld /home/accounting/ 
drwxrwxr-x. 2 root accounting 6 Jan 13 10:18 /home/accounting/

[root@localhost Downloads]#

Since the accounting group may deal with sensitive documents, we need to apply some restrictive permissions for other or world.

[root@localhost Downloads]# chmod o-rx /home/accounting/

[root@localhost Downloads]# ls -ld /home/accounting/ 
drwxrwx---. 2 root accounting 6 Jan 13 10:18 /home/accounting/

[root@localhost Downloads]#

groupadd − Used to make a new group.

Switch	Action
-g	Specifies a GID for the group
-K	Overrides specs for GID in /etc/login.defs
-o	Allows overriding non-unique group id disallowance
-p	Group password, allowing the users to activate themselves

Let's make a new group called secret. We will add a password to the group, allowing the users to add themselves with a known password.

[root@localhost]# groupadd secret

[root@localhost]# gpasswd secret 
Changing the password for group secret 
New Password:  
Re-enter new password:

[root@localhost]# exit 
exit

[centos@localhost ~]$ newgrp secret Password: [centos@localhost ~]$ groups 
secret wheel rdc

[centos@localhost ~]$

In practice, passwords for groups are not used often. Secondary groups are adequate and sharing passwords amongst other users is not a great security practice.

The groups command is used to show which group a user belongs to. We will use this, after making some changes to our current user.

usermod is used to update account attributes.

Following are the common usermod switches.

Switch	Action
-a	Appends, adds user to supplementary groups, only with the -G option
-c	Comment, updatesthe user comment value
-d	Home directory, updates the user's home directory
-G	Groups, adds or removesthe secondary user groups
-g	Group, default primary group of the user

[root@localhost]# groups centos 
centos : accounting secret

[root@localhost]#

[root@localhost]# usermod -a -G wheel centos

[root@localhost]# groups centos
centos : accounting wheel secret

[root@localhost]#

CentOS disk quotas can be enabled both; alerting the system administrator and denying further disk-storage-access to a user before disk capacity is exceeded. When a disk is full, depending on what resides on the disk, an entire system can come to a screeching halt until recovered.

Enabling Quota Management in CentOS Linux is basically a 4 step process −

Step 1 − Enable quota management for groups and users in /etc/fstab.
Step 2 − Remount the filesystem.
Step 3 − Create Quota database and generate disk usage table.
Step 4 − Assign quota policies.

Enable Quota Management in /etc/fstab

First, we want to backup our /etc/fstab filen −

[root@centosLocal centos]# cp -r /etc/fstab ./

We now have a copy of our known working /etc/fstab in the current working directory.

# 
# /etc/fstab 
# Created by anaconda on Sat Dec 17 02:44:51 2016 
# 
# Accessible filesystems, by reference, are maintained under '/dev/disk' 
# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info
# 
/dev/mapper/cl-root        /         xfs     defaults                      0 0
UUID = 4b9a40bc-9480-4     /boot     xfs     defaults                      0 0

/dev/mapper/cl-home        /home     xfs     defaults,usrquota,grpquota    0 0

/dev/mapper/cl-swap        swap      swap    defaults                      0 0

We made the following changes in the options section of /etc/fstab for the volume or Label to where quotas are to be applied for users and groups.

usrquota
grpquota

As you can see, we are using the xfs filesystem. When using xfs there are extra manual steps involved. /home is on the same disk as /. Further investigation shows / is set for noquota, which is a kernel level mounting option. We must re-configure our kernel boot options.

root@localhost rdc]# mount | grep ' / ' 
/dev/mapper/cl-root on / type xfs (rw,relatime,seclabel,attr2,inode64,noquota)

[root@localhost rdc]#

Reconfiguring Kernel Boot Options for XFS File Systems

This step is only necessary under two conditions −

When the disk/partition we are enabling quotas on, is using the xfs file system
When the kernel is passing noquota parameter to /etc/fstab at boot time

Step 1 − Make a backup of /etc/default/grub.

cp /etc/default/grub ~/

Step 2 − Modify /etc/default/grub.

Here is the default file.

GRUB_TIMEOUT=5 
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)" 
GRUB_DEFAULT=saved 
GRUB_DISABLE_SUBMENU=true 
GRUB_TERMINAL_OUTPUT="console" 
GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=cl/root rd.lvm.lv=cl/swap rhgb quiet" 
GRUB_DISABLE_RECOVERY="true"

We want to modify the following line −

GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=cl/root rd.lvm.lv=cl/swap rhgb quiet"

GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=cl/root rd.lvm.lv 
=cl/swap rhgb quiet rootflags=usrquota,grpquota"

Note − It is important we copy these changes verbatim. After we reconfigure grub.cfg, our system will fail to boot if any errors were made in the configuration. Please, try this part of the tutorial on a non-production system.

Step 3 − Backup your working grub.cfg

cp /boot/grub2/grub.cfg /boot/grub2/grub.cfg.bak

Make a new grub.cfg

[root@localhost rdc]# grub2-mkconfig -o /boot/grub2/grub.cfg 
Generating grub configuration file ... 
Found linux image: /boot/vmlinuz-3.10.0-514.el7.x86_64 
Found initrd image: /boot/initramfs-3.10.0-514.el7.x86_64.img 
Found linux image: /boot/vmlinuz-0-rescue-dbba7fa47f73457b96628ba8f3959bfd 
Found initrd image: /boot/initramfs-0-rescuedbba7fa47f73457b96628ba8f3959bfd.img 
done

[root@localhost rdc]#

Reboot

[root@localhost rdc]#reboot

If all modifications were precise, we should not have the availability to add quotas to the xfs file system.

[rdc@localhost ~]$ mount | grep ' / ' 
/dev/mapper/cl-root on / type xfs (rw,relatime,seclabel,attr2,inode64,usrquota,grpquota)
 
[rdc@localhost ~]$

We have passed the usrquota and grpquota parameters via grub.

Now, again edit /etc/fstab to include / since /homeon the same physical disk.

/dev/mapper/cl-root/xfs
defaults,usrquota,grpquota        0 0

Now let's enable the quota databases.

[root@localhost rdc]# quotacheck -acfvugM

Make sure Quotas are enabled.

[root@localhost rdc]# quotaon -ap 
group quota on / (/dev/mapper/cl-root) is on 
user quota on / (/dev/mapper/cl-root) is on 
group quota on /home (/dev/mapper/cl-home) is on 
user quota on /home (/dev/mapper/cl-home) is on 
[root@localhost rdc]#

Remount the File System

If the partition or disk is separate from the actively booted partition, we can remount without rebooting. If the quota was configured on a disk/partition booted in the root directory /, we may need to reboot the operating system. Forcing the remount and applying changes, the need to remount the filesystem may vary.

[rdc@localhost ~]$ df 
Filesystem              1K-blocks     Used      Available      Use%     Mounted on
/dev/mapper/cl-root     22447404      4081860   18365544       19%         /
devtmpfs                903448        0         903448         0%          /dev
tmpfs                   919308        100       919208         1%          /dev/shm
tmpfs                   919308        9180      910128         1%          /run
tmpfs                   919308        0         919308         0%          /sys/fs/cgroup
/dev/sda2               1268736       176612    1092124        14%         /boot
/dev/mapper/cl-var      4872192       158024    4714168        4%          /var
/dev/mapper/cl-home     18475008      37284     18437724       1%          /home
tmpfs                   183864        8         183856         1%          /run/user/1000

[rdc@localhost ~]$

As we can see, LVM volumes are in use. So it's simple to just reboot. This will remount /home and load the /etc/fstab configuration changes into active configuration.

Create Quota Database Files

CentOS is now capable of working with disk quotas on /home. To enable full quota supprt, we must run the quotacheck command.

quotacheck will create two files −

aquota.user
aquota.group

These are used to store quota information for the quota enabled disks/partitions.

Following are the common quotacheck switches.

Switch	Action
-u	Checks for user quotas
-g	Checks for group quotas
-c	Quotas should be enabled for each file system with enables quotas
-v	Displays verbose output

Add Quota Limits Per User

For this, we will use the edquota command, followed by the username −

[root@localhost rdc]# edquota centos

Disk quotas for user centos (uid 1000):  
Filesystem                   blocks       soft       hard     inodes     soft     hard 
/dev/mapper/cl-root              12          0          0         13        0        0  
/dev/mapper/cl-home            4084          0          0        140        0        0

Let's look at each column.

Filesystem − It is the filesystem quotas for the user applied to
blocks − How many blocks the user is currently using on each filesystem
soft − Set blocks for a soft limit. Soft limit allows the user to carry quota for a given time period
hard − Set blocks for a hard limit. Hard limit is total allowable quota
inodes − How many inodes the user is currently using
soft − Soft inode limit
hard − Hard inode limit

To check our current quota as a user −

[centos@localhost ~]$ quota 
Disk quotas for user centos (uid 1000):  
Filesystem             blocks     quota      limit grace    files   quota   limit   grace 
/dev/mapper/cl-home    6052604    56123456   61234568       475     0       0       [centos@localhost ~]$

Following is an error given to a user when the hard quota limit has exceeded.

[centos@localhost Downloads]$ cp CentOS-7-x86_64-LiveKDE-1611.iso.part ../Desktop/

cp: cannot create regular file ‘../Desktop/CentOS-7-x86_64-LiveKDE-
1611.iso.part’: Disk quota exceeded

[centos@localhost Downloads]$

As we can see, we are closely within this user's disk quota. Let's set a soft limit warning. This way, the user will have advance notice before quota limits expire. From experience, you will get end-user complaints when they come into work and need to spend 45 minutes clearing files to actually get to work.

As an Administrator, we can check quota usage with the repquota command.

[root@localhost Downloads]# repquota  /home  
                    Block limits                            File limits  
User            used     soft     hard     grace       used     soft     hard     grace 
----------------------------------------------------------------------------------------
root      --       0         0        0                   3        0        0        
centos    -+ 6189824  56123456 61234568                 541      520      540      6days 

[root@localhost Downloads]#

As we can see, the user centos has exceeded their hard block quota and can no longer use any more disk space on /home.

-+denotes a hard quota has been exceeded on the filesystem.

When planning quotas, it is necessary to do a little math. What an Administrator needs to know is:How many users are on the system? How much free space to allocate amongst users/groups? How many bytes make up a block on the file system?

Define quotas in terms of blocks as related to free disk-space.It is recommended to leave a "safe" buffer of free-space on the file system that will remain in worst case scenario: all quotas are simultaneously exceeded. This is especially on a partition that is used by the system for writing logs.

systemd is the new way of running services on Linux. systemd has a superceded sysvinit. systemd brings faster boot-times to Linux and is now, a standard way to manage Linux services. While stable, systemd is still evolving.

systemd as an init system, is used to manage both services and daemons that need status changes after the Linux kernel has been booted. By status change starting, stopping, reloading, and adjusting service state is applied.

First, let's check the version of systemd currently running on our server.

[centos@localhost ~]$ systemctl --version 
systemd 219 
+PAM +AUDIT +SELINUX +IMA -APPARMOR +SMACK +SYSVINIT +UTMP +LIBCRYPTSETUP 
+GCRYPT +GNUTLS +ACL     +XZ -LZ4 -SECCOMP +BLKID +ELFUTILS +KMOD +IDN

[centos@localhost ~]$

As of CentOS version 7, fully updated at the time of this writing systemd version 219 is the current stable version.

We can also analyze the last server boot time with systemd-analyze

[centos@localhost ~]$ systemd-analyze    
Startup finished in 1.580s (kernel) + 908ms (initrd) + 53.225s (userspace) = 55.713s 
[centos@localhost ~]$

When the system boot times are slower, we can use the systemd-analyze blame command.

[centos@localhost ~]$ systemd-analyze blame 
   40.882s kdump.service 
   5.775s NetworkManager-wait-online.service 
   4.701s plymouth-quit-wait.service 
   3.586s postfix.service 
   3.121s systemd-udev-settle.service 
   2.649s tuned.service 
   1.848s libvirtd.service 
   1.437s network.service 
   875ms packagekit.service 
   855ms gdm.service 
   514ms firewalld.service 
   438ms rsyslog.service
   436ms udisks2.service 
   398ms sshd.service 
   360ms boot.mount 
   336ms polkit.service 
   321ms accounts-daemon.service

When working with systemd, it is important to understand the concept of units. Units are the resources systemd knows how to interpret. Units are categorized into 12 types as follows −

.service
.socket
.device
.mount
.automount
.swap
.target
.path
.timer
.snapshot
.slice
.scope

For the most part, we will be working with .service as unit targets. It is recommended to do further research on the other types. As only .service units will apply to starting and stopping systemd services.

Each unit is defined in a file located in either −

/lib/systemd/system − base unit files
/etc/systemd/system − modified unit files started at run-time

Manage Services with systemctl

To work with systemd, we will need to get very familiar with the systemctl command. Following are the most common command line switches for systemctl.

Switch	Action
-t	Comma separated value of unit types such as service or socket
-a	Shows all loaded units
--state	Shows all units in a defined state, either: load, sub, active, inactive, etc..
-H	Executes operation remotely. Specify Host name or host and user separated by @.

Basic systemctl Usage

systemctl [operation]
example: systemctl --state [servicename.service]

For a quick look at all the services running on our box.

[root@localhost rdc]# systemctl -t service 
UNIT                       LOAD     ACTIVE      SUB     DESCRIPTION

abrt-ccpp.service          loaded   active   exited     Install ABRT coredump   hook 
abrt-oops.service          loaded   active   running    ABRT kernel log watcher 
abrt-xorg.service          loaded   active   running    ABRT Xorg log watcher 
abrtd.service              loaded   active   running    ABRT Automated Bug  Reporting Tool 
accounts-daemon.service    loaded   active   running    Accounts Service 
alsa-state.service         loaded   active   running    Manage Sound Card State (restore and store) 
atd.service                loaded   active   running    Job spooling tools 
auditd.service             loaded   active   running    Security Auditing Service 
avahi-daemon.service       loaded   active   running    Avahi mDNS/DNS-SD Stack 
blk-availability.service   loaded   active   exited     Availability of block devices 
bluetooth.service          loaded   active   running    Bluetooth service 
chronyd.service            loaded   active   running    NTP client/server

Stopping a Service

Let's first, stop the bluetooth service.

[root@localhost]# systemctl stop bluetooth

[root@localhost]# systemctl --all -t service | grep bluetooth      
bluetooth.service   loaded    inactive dead    Bluetooth service

[root@localhost]#

As we can see, the bluetooth service is now inactive.

To start the bluetooth service again.

[root@localhost]# systemctl start bluetooth

[root@localhost]# systemctl --all -t service | grep bluetooth 
bluetooth.service  loaded    active   running Bluetooth     service

[root@localhost]#

Note − We didn't specify bluetooth.service, since the .service is implied. It is a good practice to think of the unit type appending the service we are dealing with. So, from here on, we will use the .service extension to clarify we are working on service unit operations.

The primary actions that can be performed on a service are −

Start	Starts the service
Stop	Stops a service
Reload	Reloads the active configuration of a service w/o stopping it (like kill -HUP in system v init)
Restart	Starts, then stops a service
Enable	Starts a service at boot time
Disable	Stops a service from automatically starting at run time

The above actions are primarily used in the following scenarios −

Start	To bring a service up that has been put in the stopped state.
Stop	To temporarily shut down a service (for example when a service must be stopped to access files locked by the service, as when upgrading the service)
Reload	When a configuration file has been edited and we want to apply the new changes while not stopping the service.
Restart	In the same scenario as reload, but the service does not support reload.
Enable	When we want a disabled service to run at boot time.
Disable	Used primarily when there is a need to stop a service, but it starts on boot.

To check the status of a service −

[root@localhost]# systemctl status network.service 
network.service - LSB: Bring up/down networking 
Loaded: loaded (/etc/rc.d/init.d/network; bad; vendor preset: disabled) 
Active: active (exited) since Sat 2017-01-14 04:43:48 EST; 1min 31s ago 
Docs: man:systemd-sysv-generator(8)

Process: 923 ExecStart = /etc/rc.d/init.d/network start (code=exited, status = 0/SUCCESS)

localhost.localdomain systemd[1]: Starting LSB: Bring up/down networking... 
localhost.localdomain network[923]: Bringing up loopback interface:  [  OK  ] 
localhost.localdomain systemd[1]: Started LSB: Bring up/down networking.

[root@localhost]#

Show us the current status of the networking service. If we want to see all the services related to networking, we can use −

[root@localhost]# systemctl --all -t service | grep -i network 
network.service                       loaded    active    exited    LSB: Bring up/ 
NetworkManager-wait-online.service    loaded    active    exited    Network Manager  
NetworkManager.service                loaded    active    running   Network Manager 
ntpd.service                          loaded    inactive  dead      Network Time  
rhel-import-state.service             loaded    active    exited    Import network      

[root@localhost]#

For those familiar with the sysinit method of managing services, it is important to make the transition to systemd. systemd is the new way starting and stopping daemon services in Linux.

systemctl is the utility used to control systemd. systemctl provides CentOS administrators with the ability to perform a multitude of operations on systemd including −

Configure systemd units
Get status of systemd untis
Start and stop services
Enable / disable systemd services for runtime, etc.

The command syntax for systemctl is pretty basic, but can tangle with switches and options. We will present the most essential functions of systemctl needed for administering CentOS Linux.

Basic systemctl syntax: 
systemctl [OPTIONS] COMMAND [NAME]

Following are the common commands used with systemctl −

start
stop
restart
reload
status
is-active
list-units
enable
disable
cat
show

We have already discussed start, stop, reload, restart, enable and disable with systemctl. So let's go over the remaining commonly used commands.

status

In its most simple form, the status command can be used to see the system status as a whole −

[root@localhost rdc]# systemctl status 
 ● localhost.localdomain 
  State: running 
  Jobs: 0 queued
  Failed: 0 units 
  Since: Thu 2017-01-19 19:14:37 EST; 4h 5min ago 
CGroup: / 
       ├─1 /usr/lib/systemd/systemd --switched-root --system --deserialize 21 
       ├─user.slice 
       │ └─user-1002.slice 
       │   └─session-1.scope 
       │     ├─2869 gdm-session-worker [pam/gdm-password] 
       │     ├─2881 /usr/bin/gnome-keyring-daemon --daemonize --login 
       │     ├─2888 gnome-session --session gnome-classic 
       │     ├─2895 dbus-launch --sh-syntax --exit-with-session

The above output has been condensed. In the real-world systemctl status will output about 100 lines of treed process statuses.

Let's say we want to check the status of our firewall service −

[root@localhost rdc]# systemctl status firewalld 
● firewalld.service - firewalld - dynamic firewall daemon 
Loaded: loaded (/usr/lib/systemd/system/firewalld.service; enabled; vendor preset: enabled) 
Active: active (running) since Thu 2017-01-19 19:14:55 EST; 4h 12min ago 
 Docs: man:firewalld(1) 
Main PID: 825 (firewalld) 
CGroup: /system.slice/firewalld.service 
       └─825 /usr/bin/python -Es /usr/sbin/firewalld --nofork --nopid

As you see, our firewall service is currently active and has been for over 4 hours.

list-units

The list-units command allows us to list all the units of a certain type. Let's check for sockets managed by systemd −

[root@localhost]# systemctl list-units --type=socket 
UNIT                         LOAD     ACTIVE     SUB     DESCRIPTION     
avahi-daemon.socket          loaded   active  running    Avahi mDNS/DNS-SD Stack Activation Socket 
cups.socket                  loaded   active  running    CUPS Printing Service Sockets 
dbus.socket                  loaded   active  running    D-Bus System Message Bus Socket 
dm-event.socket              loaded   active  listening  Device-mapper event daemon FIFOs 
iscsid.socket                loaded   active  listening  Open-iSCSI iscsid Socket
iscsiuio.socket              loaded   active  listening  Open-iSCSI iscsiuio Socket 
lvm2-lvmetad.socket          loaded   active  running    LVM2 metadata daemon socket 
lvm2-lvmpolld.socket         loaded   active  listening  LVM2 poll daemon socket 
rpcbind.socket               loaded   active  listening  RPCbind Server Activation Socket 
systemd-initctl.socket       loaded   active  listening  /dev/initctl Compatibility Named Pipe 
systemd-journald.socket      loaded   active  running    Journal Socket 
systemd-shutdownd.socket     loaded   active  listening  Delayed Shutdown Socket 
systemd-udevd-control.socket loaded   active  running    udev Control Socket 
systemd-udevd-kernel.socket  loaded   active  running    udev Kernel Socket 
virtlockd.socket             loaded   active  listening  Virtual machine lock manager socket 
virtlogd.socket              loaded   active  listening  Virtual machine log manager socket

Ora controlliamo i servizi correnti in esecuzione -

[root@localhost rdc]# systemctl list-units --type=service 
UNIT                      LOAD     ACTIVE     SUB     DESCRIPTION 
abrt-ccpp.service         loaded   active   exited    Install ABRT coredump hook 
abrt-oops.service         loaded   active   running   ABRT kernel log watcher 
abrt-xorg.service         loaded   active   running   ABRT Xorg log watcher 
abrtd.service             loaded   active   running   ABRT Automated Bug Reporting Tool 
accounts-daemon.service   loaded   active   running   Accounts Service 
alsa-state.service        loaded   active   running   Manage Sound Card State (restore and store) 
atd.service               loaded   active   running   Job spooling tools 
auditd.service            loaded   active   running   Security Auditing Service

è attivo

Il comando is-active è un esempio di comandi systemctl progettati per restituire le informazioni sullo stato di un'unità.

[root@localhost rdc]# systemctl is-active ksm.service 
active

gatto

cat è uno dei comandi usati raramente. Invece di usare cat nella shell e digitare il percorso di un file unit, usa semplicemente systemctl cat .

[root@localhost]# systemctl cat firewalld 
# /usr/lib/systemd/system/firewalld.service
[Unit] 
Description=firewalld - dynamic firewall daemon 
Before=network.target 
Before=libvirtd.service 
Before = NetworkManager.service 
After=dbus.service 
After=polkit.service 
Conflicts=iptables.service ip6tables.service ebtables.service ipset.service 
Documentation=man:firewalld(1)

[Service] 
EnvironmentFile = -/etc/sysconfig/firewalld 
ExecStart = /usr/sbin/firewalld --nofork --nopid $FIREWALLD_ARGS ExecReload = /bin/kill -HUP $MAINPID 
# supress to log debug and error output also to /var/log/messages 
StandardOutput = null 
StandardError = null

Type = dbus 
BusName = org.fedoraproject.FirewallD1

[Install] 
WantedBy = basic.target 
Alias = dbus-org.fedoraproject.FirewallD1.service

[root@localhost]#

Ora che abbiamo esplorato sia systemd che systemctl in modo più dettagliato, usiamoli per gestire le risorse in cgroups o gruppi di controllo .

cgroups o Control Groups sono una caratteristica del kernel Linux che consente a un amministratore di allocare o limitare le risorse di sistema per i servizi e anche per il gruppo.

Per elencare i gruppi di controllo attivi in esecuzione, possiamo usare il seguente comando ps :

[root@localhost]# ps xawf -eo pid,user,cgroup,args 
8362 root     -                            \_ [kworker/1:2] 
1 root        -                           /usr/lib/systemd/systemd --switched-
   root --system --    deserialize 21 
507 root     7:cpuacct,cpu:/system.slice  /usr/lib/systemd/systemd-journald 
527 root     7:cpuacct,cpu:/system.slice  /usr/sbin/lvmetad -f 
540 root     7:cpuacct,cpu:/system.slice  /usr/lib/systemd/systemd-udevd 
715 root     7:cpuacct,cpu:/system.slice  /sbin/auditd -n 
731 root     7:cpuacct,cpu:/system.slice   \_ /sbin/audispd 
734 root     7:cpuacct,cpu:/system.slice       \_ /usr/sbin/sedispatch 
737 polkitd  7:cpuacct,cpu:/system.slice  /usr/lib/polkit-1/polkitd --no-debug 
738 rtkit    6:memory:/system.slice/rtki  /usr/libexec/rtkit-daemon 
740 dbus     7:cpuacct,cpu:/system.slice  /bin/dbus-daemon --system --
   address=systemd: --nofork --nopidfile --systemd-activation

Resource Management, a partire da CentOS 6.X, è stato ridefinito con l' implementazione di systemd init . Quando si pensa alla gestione delle risorse per i servizi, la cosa principale su cui concentrarsi sono i cgroup .cgroupssono avanzati con systemd sia in termini di funzionalità che di semplicità.

L'obiettivo di cgroups nella gestione delle risorse è: nessun servizio può arrestare il sistema nel suo insieme. Oppure nessun singolo processo di servizio (forse uno script PHP scritto male) paralizzerà la funzionalità del server consumando troppe risorse.

cgroups consente il controllo delle risorse delle unità per le seguenti risorse:

CPU - Limita le attività intensive della CPU che non sono critiche come altre attività meno intense
Memory - Limita la quantità di memoria che un servizio può consumare
Disks - Limita i / o disco

** Tempo CPU: **

Le attività che richiedono meno priorità della CPU possono avere sezioni CPU configurate personalizzate.

Diamo uno sguardo ai seguenti due servizi, ad esempio.

Servizio CPU discreto 1

[root@localhost]# systemctl cat polite.service 
# /etc/systemd/system/polite.service 
[Unit] 
Description = Polite service limits CPU Slice and Memory 
After=remote-fs.target nss-lookup.target

[Service] 
MemoryLimit = 1M 
ExecStart = /usr/bin/sha1sum /dev/zero 
ExecStop = /bin/kill -WINCH ${MAINPID} 
WantedBy=multi-user.target

# /etc/systemd/system/polite.service.d/50-CPUShares.conf 
[Service] 
CPUShares = 1024 
[root@localhost]#

Servizio CPU malvagia 2

[root@localhost]# systemctl cat evil.service 
# /etc/systemd/system/evil.service 
[Unit] 
Description = I Eat You CPU 
After=remote-fs.target nss-lookup.target

[Service] 
ExecStart = /usr/bin/md5sum /dev/zero 
ExecStop = /bin/kill -WINCH ${MAINPID} 
WantedBy=multi-user.target

# /etc/systemd/system/evil.service.d/50-CPUShares.conf 
[Service] 
CPUShares = 1024 
[root@localhost]#

Impostiamo il servizio "polite" utilizzando una priorità della CPU inferiore -

systemctl set-property polite.service CPUShares = 20  
/system.slice/polite.service
1   70.5   124.0K        -        -  

/system.slice/evil.service
1   99.5   304.0K        -        -

Come possiamo vedere, in un periodo di normale tempo di inattività del sistema, entrambi i processi non autorizzati utilizzano ancora i cicli della CPU. Tuttavia, quello impostato per avere meno intervalli di tempo utilizza meno tempo della CPU. Con questo in mente, possiamo vedere come l'utilizzo di un intervallo di tempo inferiore consentirebbe alle attività essenziali di accedere meglio alle risorse di sistema.

Per impostare i servizi per ogni risorsa, il metodo set-property definisce i seguenti parametri:

systemctl set-property name parameter=value

Fette di CPU	CPUShares
Limite di memoria	MemoryLimit
Limite di memoria morbida	MemorySoftLimit
Blocco peso IO	BlockIOWeight
Block Device Limit (specificato in / volume / path))	BlockIODeviceWeight
Leggi IO	BlockIOReadBandwidth
I / O di scrittura su disco	BlockIOReadBandwidth

Molto spesso i servizi saranno limitati dall'uso della CPU , dai limiti di memoria e da I / O di lettura / scrittura .

Dopo aver cambiato ciascuno, è necessario ricaricare systemd e riavviare il servizio -

systemctl set-property foo.service CPUShares = 250 
systemctl daemon-reload 
systemctl restart foo.service

Configurare i CGroup in CentOS Linux

Per creare cgroup personalizzati in CentOS Linux, dobbiamo prima installare i servizi e configurarli.

Step 1 - Installa libcgroup (se non è già installato).

[root@localhost]# yum install libcgroup 
Package libcgroup-0.41-11.el7.x86_64 already installed and latest version 
Nothing to do 
[root@localhost]#

Come possiamo vedere, per impostazione predefinita CentOS 7 ha libcgroup installato con il programma di installazione di tutto . L'utilizzo di un programma di installazione minimo richiederà l'installazione delle utilità libcgroup insieme a qualsiasi dipendenza.

Step 2 - Avvia e abilita il servizio cgconfig.

[root@localhost]# systemctl enable cgconfig 
Created symlink from /etc/systemd/system/sysinit.target.wants/cgconfig.service to /usr/lib/systemd/system/cgconfig.service. 
[root@localhost]# systemctl start cgconfig 
[root@localhost]# systemctl status cgconfig 
● cgconfig.service - Control Group configuration service 
Loaded: loaded (/usr/lib/systemd/system/cgconfig.service; enabled; vendor preset: disabled) 
Active: active (exited) since Mon 2017-01-23 02:51:42 EST; 1min 21s ago 
Main PID: 4692 (code=exited, status = 0/SUCCESS) 
Memory: 0B 
CGroup: /system.slice/cgconfig.service  

Jan 23 02:51:42 localhost.localdomain systemd[1]: Starting Control Group configuration service... 
Jan 23 02:51:42 localhost.localdomain systemd[1]: Started Control Group configuration service. 
[root@localhost]#

Di seguito sono riportati i comandi comuni utilizzati con Process Management: bg, fg, nohup, ps, pstree, top, kill, killall, free, uptime, nice.

Lavora con i processi

Quick Note: Process PID in Linux

In Linux a ogni processo in esecuzione viene assegnato un numero PID o ID processo. Questo PID è il modo in cui CentOS identifica un particolare processo. Come abbiamo discusso, systemd è il primo processo avviato e dato un PID di 1 in CentOS.

Pgrep viene utilizzato per ottenere il PID Linux per un dato nome di processo.

[root@CentOS]# pgrep systemd 
1 
[root@CentOS]#

Come visto, il comando pgrep restituisce il PID corrente di systemd.

Processo CentOS di base e gestione dei lavori in CentOS

Quando si lavora con i processi in Linux è importante sapere come vengono eseguiti i processi di base in primo piano e in background dalla riga di comando.

fg - Porta il processo in primo piano
bg - Sposta il processo in background
jobs - Elenco dei processi correnti allegati alla shell
ctrl+z - Combinazione di tasti Control + z per sospendere il processo corrente
& - Avvia il processo in background

Cominciamo a usare il comando di shell sleep .sleepfarà semplicemente come viene chiamato, dormirà per un periodo di tempo definito: dormire .

[root@CentOS ~]$ jobs [root@CentOS ~]$ sleep 10 & 
[1] 12454

[root@CentOS ~]$ sleep 20 & [2] 12479 [root@CentOS ~]$ jobs 
[1]-  Running                 sleep 10 & 
[2]+  Running                 sleep 20 &

[cnetos@CentOS ~]$

Ora, portiamo in primo piano il primo lavoro:

[root@CentOS ~]$ fg 1 
sleep 10

Se stai seguendo, noterai che il lavoro in primo piano è bloccato nel tuo guscio. Ora mettiamo il processo in stato di stop, quindi riattivalo in background.

Premi control + z
Digita: bg 1, inviando il primo lavoro in background e avviandolo.

[root@CentOS ~]$ fg 1 sleep 20 ^Z [1]+ Stopped sleep 20 [root@CentOS ~]$ bg 1 
[1]+ sleep 20 &

[root@CentOS ~]$

nohup

Quando si lavora da una shell o da un terminale, vale la pena notare che per impostazione predefinita tutti i processi e i lavori collegati alla shell verranno terminati quando la shell viene chiusa o l'utente si disconnette. Quando si utilizza nohup, il processo continuerà a essere eseguito se l'utente si disconnette o chiude la shell a cui è collegato il processo.

[root@CentOS]# nohup ping www.google.com & 
[1] 27299 
nohup: ignoring input and appending output to ‘nohup.out’

[root@CentOS]# pgrep ping 
27299

[root@CentOS]# kill -KILL `pgrep ping` 
[1]+  Killed                  nohup ping www.google.com

[root@CentOS rdc]# cat nohup.out  
PING www.google.com (216.58.193.68) 56(84) bytes of data. 
64 bytes from sea15s07-in-f4.1e100.net (216.58.193.68): icmp_seq = 1 ttl = 128
time = 51.6 ms 
64 bytes from sea15s07-in-f4.1e100.net (216.58.193.68): icmp_seq = 2 ttl = 128
time = 54.2 ms 
64 bytes from sea15s07-in-f4.1e100.net (216.58.193.68): icmp_seq = 3 ttl = 128
time = 52.7 ms

comando ps

Il psviene comunemente utilizzato dagli amministratori per esaminare le istantanee di un processo specifico. ps è comunemente usato con grep per filtrare un processo specifico da analizzare.

[root@CentOS ~]$ ps axw | grep python 
762   ?        Ssl    0:01 /usr/bin/python -Es /usr/sbin/firewalld --nofork -nopid 
1296  ?        Ssl    0:00 /usr/bin/python -Es /usr/sbin/tuned -l -P 
15550 pts/0    S+     0:00 grep --color=auto python

Nel comando precedente, vediamo tutti i processi che utilizzano l' interprete python . Con i risultati è stato incluso anche il nostro comando grep, alla ricerca della stringa python .

Di seguito sono riportate le opzioni della riga di comando più comuni utilizzate con ps .

Interruttore	Azione
un	Esclude i vincoli dei soli processi di reporting per l'utente corrente
X	Mostra i processi non collegati a una tty o shell
w	Formatta la visualizzazione ampia dell'output
e	Mostra l'ambiente dopo il comando
-e	Seleziona tutti i processi
-o	Output formattato definito dall'utente
-u	Mostra tutti i processi di un utente specifico
-C	Mostra tutti i processi per nome o ID processo
--ordinare	Ordina i processi per definizione

Per vedere tutti i processi in uso dall'utente nessuno -

[root@CentOS ~]$ ps -u nobody PID TTY TIME CMD 1853 ? 00:00:00 dnsmasq [root@CentOS ~]$

Per visualizzare tutte le informazioni sul processo firewalld :

[root@CentOS ~]$ ps -wl -C firewalld F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD 0 S 0 762 1 0 80 0 - 81786 poll_s ? 00:00:01 firewalld [root@CentOS ~]$

Vediamo quali processi consumano più memoria:

[root@CentOS ~]$ ps aux --sort=-pmem | head -10 USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND cnetos 6130 0.7 5.7 1344512 108364 ? Sl 02:16 0:29 /usr/bin/gnome-shell cnetos 6449 0.0 3.4 1375872 64440 ? Sl 02:16 0:00 /usr/libexec/evolution-calendar-factory root 5404 0.6 2.1 190256 39920 tty1 Ssl+ 02:15 0:27 /usr/bin/Xorg :0 -background none -noreset -audit 4 -verbose -auth /run/gdm/auth-for-gdm-iDefCt/database -seat seat0 -nolisten tcp vt1 cnetos 6296 0.0 1.7 1081944 32136 ? Sl 02:16 0:00 /usr/libexec/evolution/3.12/evolution-alarm-notify cnetos 6350 0.0 1.5 560728 29844 ? Sl 02:16 0:01 /usr/bin/prlsga cnetos 6158 0.0 1.4 1026956 28004 ? Sl 02:16 0:00 /usr/libexec/gnome-shell-calendar-server cnetos 6169 0.0 1.4 1120028 27576 ? Sl 02:16 0:00 /usr/libexec/evolution-source-registry root 762 0.0 1.4 327144 26724 ? Ssl 02:09 0:01 /usr/bin/python -Es /usr/sbin/firewalld --nofork --nopid cnetos 6026 0.0 1.4 1090832 26376 ? Sl 02:16 0:00 /usr/libexec/gnome-settings-daemon [root@CentOS ~]$

Visualizza tutti i processi in base ai centri utente e al formato, visualizzando l'output personalizzato

[cnetos@CentOS ~]$ ps -u cnetos -o pid,uname,comm 
   PID    USER     COMMAND 
   5802  centos   gnome-keyring-d 
   5812  cnetos   gnome-session 
   5819  cnetos   dbus-launch 
   5820  cnetos   dbus-daemon 
   5888  cnetos   gvfsd 
   5893  cnetos   gvfsd-fuse 
   5980  cnetos   ssh-agent   
   5996  cnetos   at-spi-bus-laun

comando pstree

pstreeè simile a ps ma non è usato spesso. Visualizza i processi in modo più ordinato.

[centos@CentOS ~]$ pstree 
  systemd─┬─ModemManager───2*[{ModemManager}] 
          ├─NetworkManager─┬─dhclient 
          │                └─2*[{NetworkManager}] 
          ├─2*[abrt-watch-log] 
          ├─abrtd 
          ├─accounts-daemon───2*[{accounts-daemon}] 
          ├─alsactl 
          ├─at-spi-bus-laun─┬─dbus-daemon───{dbus-daemon} 
          │                 └─3*[{at-spi-bus-laun}] 
          ├─at-spi2-registr───2*[{at-spi2-registr}] 
          ├─atd 
          ├─auditd─┬─audispd─┬─sedispatch 
          │        │         └─{audispd} 
          │        └─{auditd} 
          ├─avahi-daemon───avahi-daemon 
          ├─caribou───2*[{caribou}] 
          ├─cgrulesengd 
          ├─chronyd 
          ├─colord───2*[{colord}] 
          ├─crond 
          ├─cupsd

L'output totale di pstree può superare le 100 righe. Di solito, ps fornisce informazioni più utili.

Comando in alto

topè uno dei comandi più utilizzati per la risoluzione dei problemi di prestazioni in Linux. È utile per le statistiche in tempo reale e il monitoraggio dei processi in Linux. Di seguito è riportato l'output predefinito di top quando viene attivato dalla riga di comando.

Tasks: 170 total,   1 running, 169 sleeping,   0 stopped,   0 zombie 
%Cpu(s):  2.3 us,  2.0 sy,  0.0 ni, 95.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st 
KiB Mem :  1879668 total,   177020 free,   607544 used,  1095104 buff/cache 
KiB Swap:  3145724 total,  3145428 free,      296 used.  1034648 avail Mem 
 
PID    USER     PR   NI    VIRT     RES   SHR    S  %CPU  %MEM   TIME+   COMMAND
5404   root     20   0    197832   48024  6744   S   1.3   2.6  1:13.22   Xorg
8013   centos   20   0    555316   23104  13140  S   1.0   1.2  0:14.89   gnome-terminal-
6339   centos   20   0    332336   6016   3248   S   0.3   0.3  0:23.71   prlcc
6351   centos   20   0    21044    1532   1292   S   0.3   0.1  0:02.66   prlshprof

Tasti di scelta rapida comuni utilizzati durante l'esecuzione di top ( è possibile accedere ai tasti di scelta rapida premendo il tasto mentre top è in esecuzione nella shell).

Comando	Azione
b	Abilita / disabilita l'evidenziazione in grassetto nel menu in alto
z	Cambia lo schema dei colori
l	Cicla l'intestazione media del carico
m	Cicla l'intestazione media della memoria
t	Intestazione delle informazioni sull'attività
h	Menu della guida
MAIUSC + F	Personalizza l'ordinamento e la visualizzazione dei campi

Di seguito sono riportate le opzioni della riga di comando comuni per top .

Comando	Azione
-o	Ordina per colonna (può anteporre - o + per ordinare in ordine crescente o decrescente)
-u	Mostra solo i processi di un utente specificato
-d	Aggiorna il tempo di ritardo della parte superiore
-O	Restituisce un elenco di colonne che in alto possono applicare l'ordinamento

Ordinamento schermata delle opzioni in alto, presentato usando Shift + F . Questa schermata consente la personalizzazione della visualizzazione superiore e delle opzioni di ordinamento.

Fields Management for window 1:Def, whose current sort field is %MEM 
Navigate with Up/Dn, Right selects for move then <Enter> or Left commits, 
 'd' or <Space> toggles display, 's' sets sort.  Use 'q' or <Esc> to end!
 
* PID     = Process Id             TGID    = Thread Group Id      
* USER    = Effective User Name    ENVIRON = Environment vars     
* PR      = Priority               vMj     = Major Faults delta   
* NI      = Nice Value             vMn     = Minor Faults delta   
* VIRT    = Virtual Image (KiB)    USED    = Res+Swap Size (KiB)  
* RES     = Resident Size (KiB)    nsIPC   = IPC namespace Inode  
* SHR     = Shared Memory (KiB)    nsMNT   = MNT namespace Inode
* S       = Process Status         nsNET   = NET namespace Inode  
* %CPU    = CPU Usage              nsPID   = PID namespace Inode  
* %MEM    = Memory Usage (RES)     nsUSER  = USER namespace Inode 
* TIME+   = CPU Time, hundredths   nsUTS   = UTS namespace Inode  
* COMMAND = Command Name/Line 
PPID    = Parent Process pid
UID     = Effective User Id

in alto , che mostra i processi per l'utente rdc e ordinati in base all'utilizzo della memoria -

PID   USER  %MEM  PR  NI    VIRT    RES    SHR    S %CPU     TIME+    COMMAND
 6130  rdc    6.2  20   0  1349592  117160  33232  S  0.0   1:09.34    gnome-shell
 6449  rdc    3.4  20   0  1375872   64428  21400  S  0.0   0:00.43    evolution-calen
 6296  rdc    1.7  20   0  1081944   32140  22596  S  0.0   0:00.40    evolution-alarm
 6350  rdc    1.6  20   0   560728   29844   4256  S  0.0   0:10.16    prlsga
 6281  rdc    1.5  20   0  1027176   28808  17680  S  0.0   0:00.78    nautilus
 6158  rdc    1.5  20   0  1026956   28004  19072  S  0.0   0:00.20    gnome-shell-cal

Visualizzazione di campi superiori validi (condensati) -

[centos@CentOS ~]$ top -O 
PID 
PPID 
UID 
USER 
RUID 
RUSER 
SUID 
SUSER 
GID 
GROUP 
PGRP 
TTY 
TPGID

kill Command

Il killcomando viene utilizzato per terminare un processo dalla shell dei comandi tramite il suo PID. Quando si uccide un processo, è necessario specificare un segnale da inviare. Il segnale fa sapere al kernel come vogliamo terminare il processo. I segnali più comunemente usati sono:

SIGTERMè implicito poiché il kernel fa sapere a un processo che dovrebbe fermarsi non appena è sicuro farlo. SIGTERM offre al processo l'opportunità di uscire con garbo ed eseguire operazioni di uscita sicure.
SIGHUPla maggior parte dei demoni si riavvierà quando verrà inviato SIGHUP . Viene spesso utilizzato nei processi quando sono state apportate modifiche a un file di configurazione.
SIGKILLpoiché SIGTERM equivale a chiedere l'arresto di un processo. Il kernel necessita di un'opzione per terminare un processo che non rispetterà le richieste. Quando un processo viene bloccato , l' opzione SIGKILL viene utilizzata per arrestare il processo in modo esplicito.

Per una lista fuori tutti i segnali che possono essere inviati con uccidere l' -l opzione può essere utilizzata -

[root@CentOS]# kill -l 
1) SIGHUP           2) SIGINT         3) SIGQUIT        4) SIGILL         5) SIGTRAP
6) SIGABRT          7) SIGBUS         8) SIGFPE         9) SIGKILL       10) SIGUSR1
11) SIGSEGV        12) SIGUSR2       13) SIGPIPE       14) SIGALRM       15) SIGTERM
16) SIGSTKFLT      17) SIGCHLD       18) SIGCONT       19) SIGSTOP       20) SIGTSTP
21) SIGTTIN        22) SIGTTOU       23) SIGURG        24) SIGXCPU       25) SIGXFSZ
26) SIGVTALRM      27) SIGPROF       28) SIGWINCH      29) SIGIO         30) SIGPWR
31) SIGSYS         34) SIGRTMIN      35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3
38) SIGRTMIN+4     39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    42) SIGRTMIN+8
43) SIGRTMIN+9     44) SIGRTMIN+10   45) SIGRTMIN+11   46) SIGRTMIN+12   47) SIGRTMIN+13 
48) SIGRTMIN+14    49) SIGRTMIN+15   50) SIGRTMAX-14   51) SIGRTMAX-13   52) SIGRTMAX-12 
53) SIGRTMAX-11    54) SIGRTMAX-10   55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7
58) SIGRTMAX-6     59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    62) SIGRTMAX-2
63) SIGRTMAX-1     64) SIGRTMAX

[root@CentOS rdc]#

Utilizzo di SIGHUP per riavviare il sistema.

[root@CentOS]# pgrep systemd 
1 
464 
500 
643 
15071

[root@CentOS]# kill -HUP 1

[root@CentOS]# pgrep systemd
1 
464 
500 
643 
15196 
15197 
15198

[root@CentOS]#

pkillconsentirà all'amministratore di inviare un segnale di kill tramite il nome del processo.

[root@CentOS]# pgrep ping 
19450 
[root@CentOS]# pkill -9 ping 
[root@CentOS]# pgrep ping 
[root@CentOS]#

killallucciderà tutti i processi. Fai attenzione a usare killall come root, poiché ucciderà tutti i processi per tutti gli utenti.

[root@CentOS]# killall chrome

Comando gratuito

freeè un comando piuttosto semplice spesso utilizzato per controllare rapidamente la memoria di un sistema. Visualizza la quantità totale di memoria fisica e di swap utilizzata.

[root@CentOS]# free 
             total       used      free      shared      buff/cache      available 
Mem:        1879668     526284    699796     10304        653588          1141412 
Swap:       3145724          0    3145724

[root@CentOS]#

bel comando

niceconsentirà a un amministratore di impostare la priorità di pianificazione di un processo in termini di utilizzo della CPU. La bellezza è fondamentalmente il modo in cui il kernel pianificherà intervalli di tempo della CPU per un processo o un lavoro. Per impostazione predefinita, si presume che al processo sia concesso lo stesso accesso alle risorse della CPU.

Innanzitutto, usiamo top per verificare la correttezza dei processi attualmente in esecuzione.

PID   USER   PR   NI    VIRT    RES    SHR   S  %CPU  %MEM     TIME+    COMMAND
28    root   39   19       0      0      0   S  0.0   0.0    0:00.17    khugepaged
690   root   39   19   16808   1396   1164   S  0.0   0.1    0:00.01    alsactl]
9598  rdc    39   19  980596  21904  10284   S  0.0   1.2    0:00.27    tracker-extract
9599  rdc    39   19  469876   9608   6980   S  0.0   0.5    0:00.04    tracker-miner-a
9609  rdc    39   19  636528  13172   8044   S  0.0   0.7    0:00.12    tracker-miner-f
9611  rdc    39   19  469620   8984   6496   S  0.0   0.5    0:00.02    tracker-miner-u
27    root   25    5       0      0      0   S  0.0   0.0    0:00.00    ksmd
637   rtkit  21    1  164648   1276   1068   S  0.0   0.1    0:00.11    rtkit-daemon
1     root   20    0  128096   6712   3964   S  0.3   0.4    0:03.57    systemd
2     root   20    0       0      0      0   S  0.0   0.0    0:00.01    kthreadd
3     root   20    0       0      0      0   S  0.0   0.0    0:00.50    ksoftirqd/0
7     root   20    0       0      0      0   S  0.0   0.0    0:00.00    migration/0
8     root   20    0       0      0      0   S  0.0   0.0    0:00.00    rcu_bh
9     root   20    0       0      0      0   S  0.0   0.0    0:02.07    rcu_sched

Vogliamo concentrarci sulla colonna NICE rappresentata da NI . L'intervallo di gentilezza può essere compreso tra -20 e positivo 19. -20 rappresenta la massima priorità assegnata.

nohup nice --20 ping www.google.com &

renice

renice ci permette di cambiare la priorità corrente di un processo già in esecuzione.

renice 17 -p 30727

Il comando precedente abbasserà la priorità del nostro comando del processo ping .

firewalld è il controller front-end predefinito per iptables su CentOS. Il front-end firewalld ha due vantaggi principali rispetto a iptables non elaborati:

Utilizza zone facili da configurare e implementare per astrarre catene e regole.
I set di regole sono dinamici, il che significa che le connessioni stateful non vengono interrotte quando le impostazioni vengono modificate e / o modificate.

Ricorda, firewalld è il wrapper per iptables, non un sostituto. Sebbene i comandi iptables personalizzati possano essere utilizzati con firewalld , si consiglia di utilizzare firewalld per non interrompere la funzionalità del firewall.

Innanzitutto, assicuriamoci che firewalld sia avviato e abilitato.

[root@CentOS rdc]# systemctl status firewalld 
● firewalld.service - firewalld - dynamic firewall daemon 
Loaded: loaded (/usr/lib/systemd/system/firewalld.service; enabled; vendor preset: enabled) 
Active: active (running) since Thu 2017-01-26 21:42:05 MST; 3h 46min ago 
 Docs: man:firewalld(1) 
Main PID: 712 (firewalld) 
  Memory: 34.7M 
 CGroup: /system.slice/firewalld.service 
       └─712 /usr/bin/python -Es /usr/sbin/firewalld --nofork --nopid

Possiamo vedere, firewalld è sia attivo (per l'avvio all'avvio) che attualmente in esecuzione. Se inattivo o non avviato possiamo utilizzare -

systemctl start firewalld && systemctl enable firewalld

Ora che abbiamo configurato il nostro servizio firewalld, assicuriamoci che sia operativo.

[root@CentOS]# firewall-cmd --state 
running 
[root@CentOS]#

Possiamo vedere, il servizio firewalld è completamente funzionante.

Firewalld lavora sul concetto di zone . Una zona viene applicata alle interfacce di rete tramite Network Manager. Ne discuteremo nella configurazione della rete . Ma per ora, per impostazione predefinita, la modifica della zona predefinita cambierà tutti gli adattatori di rete rimasti nello stato predefinito di "Zona predefinita".

Diamo una rapida occhiata a ogni zona che viene fornita con firewalld .

Sr.No.	Zona e descrizione
1	drop Livello di fiducia basso. Tutte le connessioni in entrata e i pacchetti vengono interrotti e solo le connessioni in uscita sono possibili tramite statefullness
2	block Alle connessioni in entrata viene risposto con un messaggio icmp che informa l'iniziatore che la richiesta è vietata
3	public Tutte le reti sono limitate. Tuttavia, le connessioni in entrata selezionate possono essere esplicitamente consentite
4	external Configura firewalld per NAT. La rete interna rimane privata ma raggiungibile
5	dmz Sono consentite solo alcune connessioni in entrata. Utilizzato per i sistemi in isolamento DMZ
6	work Per impostazione predefinita, fidarsi di più computer sulla rete presupponendo che il sistema si trovi in un ambiente di lavoro protetto
7	hone Per impostazione predefinita, più servizi non sono filtrati. Supponendo che un sistema si trovi su una rete domestica in cui verranno utilizzati servizi come NFS, SAMBA e SSDP
8	trusted Tutte le macchine sulla rete sono affidabili. La maggior parte delle connessioni in entrata sono consentite senza restrizioni.This is not meant for interfaces exposed to the Internet

Le zone più comuni da utilizzare sono: pubblica, drop, lavoro e casa.

Alcuni scenari in cui verrà utilizzata ciascuna zona comune sono:

public- È la zona più comune utilizzata da un amministratore. Ti consentirà di applicare le impostazioni personalizzate e di rispettare le specifiche RFC per le operazioni su una LAN.
drop- Un buon esempio di quando utilizzare drop è in una conferenza sulla sicurezza, su una rete Wi-Fi pubblica o su un'interfaccia connessa direttamente a Internet. drop presume che tutte le richieste non richieste siano dannose, inclusi i probe ICMP. Quindi qualsiasi richiesta fuori dallo stato non riceverà risposta. Lo svantaggio del drop è che può interrompere la funzionalità delle applicazioni in determinate situazioni che richiedono una rigorosa conformità RFC.
work- Sei su una LAN aziendale semi-sicura. Dove tutto il traffico può essere considerato moderatamente sicuro. Ciò significa che non è WiFi e forse abbiamo IDS, IPS e sicurezza fisica o 802.1x. Dovremmo anche avere familiarità con le persone che utilizzano la LAN.
home- Sei su una LAN domestica. Sei personalmente responsabile di ogni sistema e utente sulla LAN. Conosci ogni macchina sulla LAN e che nessuna è stata compromessa. Spesso vengono proposti nuovi servizi per la condivisione di file multimediali tra persone fidate e non è necessario dedicare tempo extra per motivi di sicurezza.

Le zone e le interfacce di rete funzionano su un livello da uno a molti. Un'interfaccia di rete può avere solo una singola zona applicata alla volta. Mentre, una zona può essere applicata a molte interfacce contemporaneamente.

Vediamo quali zone sono disponibili e quali sono le zone attualmente applicate.

[root@CentOS]# firewall-cmd --get-zones 
 work drop internal external trusted home dmz public block

[root@CentOS]# firewall-cmd --get-default-zone 
public
[root@CentOS]#

Pronto per aggiungere alcune regole personalizzate in firewalld?

Per prima cosa, vediamo come appare la nostra scatola, a un portscanner dall'esterno.

bash-3.2# nmap -sS -p 1-1024 -T 5  10.211.55.1
 
Starting Nmap 7.30 ( https://nmap.org ) at 2017-01-27 23:36 MST 
Nmap scan report for centos.shared (10.211.55.1) 
Host is up (0.00046s latency). 
Not shown: 1023 filtered ports 
PORT   STATE SERVICE 
22/tcp open  ssh


Nmap done: 1 IP address (1 host up) scanned in 3.71 seconds 
bash-3.2#

Consentiamo alle richieste in arrivo sulla porta 80.

Innanzitutto, controlla quale zona è applicata come predefinita.

[root@CentOs]# firewall-cmd --get-default-zone 
public
[root@CentOS]#

Quindi, impostare la regola che consente la porta 80 sulla zona predefinita corrente.

[root@CentOS]# firewall-cmd --zone=public --add-port = 80/tcp 
success
[root@CentOS]#

Ora, controlliamo la nostra casella dopo aver consentito le connessioni alla porta 80.

bash-3.2# nmap -sS -p 1-1024 -T 5  10.211.55.1

Starting Nmap 7.30 ( https://nmap.org ) at 2017-01-27 23:42 MST 
Nmap scan report for centos.shared (10.211.55.1) 
Host is up (0.00053s latency). 
Not shown: 1022 filtered ports 
PORT   STATE  SERVICE 
22/tcp open   ssh 
80/tcp closed http

Nmap done: 1 IP address (1 host up) scanned in 3.67 seconds 
bash-3.2#

Ora consente il traffico non richiesto a 80.

Mettiamo la zona predefinita da eliminare e vediamo cosa succede alla scansione delle porte.

[root@CentOS]# firewall-cmd --set-default-zone=drop 
success

[root@CentOS]# firewall-cmd --get-default-zone 
drop

[root@CentOs]#

Ora scansioniamo l'host con l'interfaccia di rete in una zona più sicura.

bash-3.2# nmap -sS -p 1-1024 -T 5  10.211.55.1 
Starting Nmap 7.30 ( https://nmap.org ) at 2017-01-27 23:50 MST 
Nmap scan report for centos.shared (10.211.55.1) 
Host is up (0.00094s latency). 
All 1024 scanned ports on centos.shared (10.211.55.1) are filtered

Nmap done: 1 IP address (1 host up) scanned in 12.61 seconds 
bash-3.2#

Ora tutto viene filtrato dall'esterno.

Come dimostrato di seguito, l'host non risponderà nemmeno alle richieste di ping ICMP quando è in calo .

bash-3.2# ping 10.211.55.1 
PING 10.211.55.1 (10.211.55.1): 56 data bytes 
Request timeout for icmp_seq 0 
Request timeout for icmp_seq 1 
Request timeout for icmp_seq 2

Impostiamo nuovamente la zona predefinita su pubblica .

[root@CentOs]# firewall-cmd --set-default-zone=public 
success

[root@CentOS]# firewall-cmd --get-default-zone 
public

[root@CentOS]#

Ora controlliamo le nostre attuali regole di filtraggio in pubblico .

[root@CentOS]# firewall-cmd --zone=public --list-all 
public (active) 
target: default 
icmp-block-inversion: no 
interfaces: enp0s5 
sources:  
services: dhcpv6-client ssh 
ports: 80/tcp 
protocols:  
masquerade: no 
forward-ports:  
sourceports:  
icmp-blocks:  
rich rules:

[root@CentOS rdc]#

Come configurato, la nostra regola di filtro della porta 80 è solo nel contesto della configurazione in esecuzione. Ciò significa che una volta che il sistema viene riavviato o il servizio firewalld viene riavviato, la nostra regola verrà eliminata.

Presto configureremo un demone httpd , quindi rendiamo le nostre modifiche persistenti -

[root@CentOS]# firewall-cmd --zone=public --add-port=80/tcp --permanent 
success

[root@CentOS]# systemctl restart firewalld

[root@CentOS]#

Ora la nostra regola della porta 80 nella zona pubblica è persistente durante i riavvii e i riavvii del servizio.

Di seguito sono riportati i comandi firewalld comuni applicati con firewall-cmd .

Comando	Azione
firewall-cmd --get-zone	Elenca tutte le zone che possono essere applicate a un'interfaccia
firewall-cmd: stato	Restituisce lo stato corrente del servizio firewalld
firewall-cmd --get-default-zone	Ottiene la zona predefinita corrente
firewall-cmd --set-default-zone = <zone>	Imposta la zona predefinita nel contesto corrente
firewall-cmd --get-active-zone	Ottiene le zone correnti nel contesto applicato a un'interfaccia
firewall-cmd --zone = <zone> --list-all	Elenca la configurazione della zona fornita
firewall-cmd --zone = <zone> --addport = <protocollo di porta / trasporto>	Applica una regola di porta al filtro di zona
--permanente	Rende persistenti le modifiche alla zona. Il flag viene utilizzato in linea con i comandi di modifica

Questi sono i concetti di base dell'amministrazione e della configurazione di firewalld .

La configurazione dei servizi firewall basati su host in CentOS può essere un'attività complessa in scenari di rete più sofisticati. L'utilizzo avanzato e la configurazione di firewalld e iptables in CentOS possono richiedere un intero tutorial. Tuttavia, abbiamo presentato le basi che dovrebbero essere sufficienti per completare la maggior parte delle attività quotidiane.

PHP è uno dei linguaggi web più prolifici in uso oggi. L'installazione di uno stack LAMP su CentOS è qualcosa che ogni amministratore di sistema dovrà eseguire, molto probabilmente prima o poi.

Uno Stack LAMP tradizionale è costituito da (L) inux (A) pache (M) ySQL (P) HP.

Ci sono tre componenti principali in uno stack LAMP su CentOS -

Server web
Piattaforma / linguaggio di sviluppo Web
Server database

Note- Il termine LAMP Stack può includere anche le seguenti tecnologie: PostgreSQL, MariaDB, Perl, Python, Ruby, NGINX Webserver.

Per questo tutorial, ci atterremo al tradizionale stack LAMP di CentOS GNU Linux: server web Apache, server database MySQL e PHP.

In realtà useremo MariaDB. I file di configurazione, i database e le tabelle di MySQL sono trasparenti per MariaDB. MariaDB è ora incluso nel repository CentOS standard invece di MySQL. Ciò è dovuto alle limitazioni delle licenze e alla conformità open source, poiché Oracle ha rilevato lo sviluppo di MySQL.

La prima cosa che dobbiamo fare è installare Apache.

[root@CentOS]# yum install httpd
Loaded plugins: fastestmirror, langpacks
base
| 3.6 kB  00:00:00
extras
| 3.4 kB  00:00:00
updates
| 3.4 kB  00:00:00
extras/7/x86_64/primary_d
| 121 kB  00:00:00
Loading mirror speeds from cached hostfile
* base: mirror.sigmanet.com
* extras: linux.mirrors.es.net
* updates: mirror.eboundhost.com
Resolving Dependencies
--> Running transaction check
---> Package httpd.x86_64 0:2.4.6-45.el7.centos will be installed
--> Processing Dependency: httpd-tools = 2.4.6-45.el7.centos for package:
httpd-2.4.6-45.el7.centos.x86_64
--> Processing Dependency: /etc/mime.types for package: httpd-2.4.645.el7.centos.x86_64
--> Running transaction check
---> Package httpd-tools.x86_64 0:2.4.6-45.el7.centos will be installed
---> Package mailcap.noarch 0:2.1.41-2.el7 will be installed
--> Finished Dependency Resolution
Installed:
httpd.x86_64 0:2.4.6-45.el7.centos

Dependency Installed:
httpd-tools.x86_64 0:2.4.6-45.el7.centos
mailcap.noarch 0:2.1.41-2.el7

Complete!
[root@CentOS]#

Configuriamo il servizio httpd .

[root@CentOS]# systemctl start httpd && systemctl enable httpd

Ora, assicuriamoci che il server web sia accessibile tramite firewalld.

bash-3.2# nmap -sS -p 1-1024 -T 5  -sV 10.211.55.1 
Starting Nmap 7.30 ( https://nmap.org ) at 2017-01-28 02:00 MST 
Nmap scan report for centos.shared (10.211.55.1) 
Host is up (0.00054s latency). 
Not shown: 1022 filtered ports 
PORT   STATE SERVICE VERSION 
22/tcp open  ssh     OpenSSH 6.6.1 (protocol 2.0) 
80/tcp open  http    Apache httpd 2.4.6 ((CentOS))

Service detection performed. Please report any incorrect results at 
https://nmap.org/submit/ . 
Nmap done: 1 IP address (1 host up) scanned in 10.82 seconds bash-3.2#

Come puoi vedere dal probe del servizio nmap, il server web Apache è in ascolto e risponde alle richieste sull'host CentOS.

Installa MySQL Database Server

[root@CentOS rdc]# yum install mariadb-server.x86_64 && yum install mariadb-
devel.x86_64 && mariadb.x86_64 && mariadb-libs.x86_64

Stiamo installando i seguenti pacchetti di repository per MariaDB -

mariadb-server.x86_64

Il pacchetto principale del demone di MariaDB Server.

mariadb-devel.x86_64

I file devono essere compilati dall'origine con compatibilità MySQL / MariaDB.

mariadb.x86_64

Utilità client MariaDB per l'amministrazione del server MariaDB dalla riga di comando.

mariadb-libs.x86_64

Librerie comuni per MariaDB che potrebbero essere necessarie per altre applicazioni compilate con supporto MySQL / MariaDB.

Ora, iniziamo e abilitiamo il servizio MariaDB.

[root@CentOS]# systemctl start mariadb 
[root@CentOS]# systemctl enable  mariadb

Note- A differenza di Apache, non abiliteremo le connessioni a MariaDB attraverso il nostro firewall basato su host (firewalld). Quando si utilizza un server database, è considerata la migliore pratica di sicurezza consentire solo connessioni socket locali, a meno che non sia specificamente necessario l'accesso al socket remoto.

Assicuriamoci che il server MariaDB accetti le connessioni.

[root@CentOS#] netstat -lnt 
Active Internet connections (only servers) 
Proto     Recv-Q     Send-Q     Local Address        Foreign Address      State       
tcp            0          0     0.0.0.0:3306         0.0.0.0:*            LISTEN      
tcp            0          0     0.0.0.0:111          0.0.0.0:*            LISTEN      
tcp            0          0     192.168.122.1:53     0.0.0.0:*            LISTEN      
tcp            0          0     0.0.0.0:22           0.0.0.0:*            LISTEN      
tcp            0          0     127.0.0.1:631        0.0.0.0:*            LISTEN      
tcp            0          0     127.0.0.1:25         0.0.0.0:*            LISTEN 
     
[root@CentOS rdc]#

Come possiamo vedere, MariaDB è in ascolto sulla porta 3306 tcp. Lasceremo il nostro firewall basato su host (firewalld) che blocca le connessioni in entrata alla porta 3306.

Installa e configura PHP

[root@CentOS#]  yum install php.x86_64 && php-common.x86_64 && php-mysql.x86_64 
&& php-mysqlnd.x86_64 && php-pdo.x86_64 && php-soap.x86_64 && php-xml.x86_64

Consiglierei di installare i seguenti pacchetti php per una compatibilità comune -

php-common.x86_64
php-mysql.x86_64
php-mysqlnd.x86_64
php-pdo.x86_64
php-soap.x86_64
php-xml.x86_64

[root@CentOS]# yum install -y php-common.x86_64 php-mysql.x86_64 php-
mysqlnd.x86_64 php-pdo.x86_64 php-soap.x86_64 php-xml.x86_64

Questo è il nostro semplice file php che si trova nella webroot Apache di / var / www / html /

[root@CentOS]# cat /var/www/html/index.php  
<html> 
   <head> 
      <title>PHP Test Page</title> 
   </head>
   
   <body> 
      PHP Install 
      <?php 
         echo "We are now running PHP on GNU Centos Linux!<br />" 
      ?> 
   </body> 
</html>

[root@CentOS]#

Cambiamo il gruppo proprietario della nostra pagina con l'utente di sistema con cui è in esecuzione il nostro demone http.

[root@CentOS]# chgrp httpd /var/www/html/index.php && chmod g+rx /var/www/html/index.php
---

Quando richiesto manualmente tramite ncat.

bash-3.2# ncat 10.211.55.1 80 
   GET / index.php 
   HTTP/1.1 200 OK 
   Date: Sat, 28 Jan 2017 12:06:02 GMT 
   Server: Apache/2.4.6 (CentOS) PHP/5.4.16 
   X-Powered-By: PHP/5.4.16 
   Content-Length: 137 
   Connection: close 
   Content-Type: text/html; charset=UTF-8
   
<html> 
   <head> 
      <title>PHP Test Page</title> 
   </head>
   
   <body> 
      PHP Install 
      We are now running PHP on GNU Centos Linux!<br />
   </body> 
</html>

bash-3.2#

PHP e LAMP sono tecnologie di programmazione web molto popolari. L'installazione e la configurazione di LAMP appariranno sicuramente nella tua lista di esigenze come amministratore di CentOS. I pacchetti CentOS facili da usare hanno richiesto molto lavoro dalla compilazione di Apache, MySQL e PHP dal codice sorgente.

Python è un linguaggio interpretato ampiamente utilizzato che ha portato professionalità nel mondo della codifica di applicazioni con script su Linux (e altri sistemi operativi). Laddove Perl era una volta lo standard del settore, Python ha superato Perl sotto molti aspetti.

Alcuni punti di forza di Python rispetto a Perl sono:

Rapida progressione nell'affinamento
Biblioteche standard per la lingua
La leggibilità del codice è pensata nella definizione del linguaggio
Molti framework professionali per tutto, dal supporto della GUI allo sviluppo web

Python può fare tutto ciò che Perl può fare, e in molti casi in modo migliore. Sebbene Perl abbia ancora il suo posto nella cassetta degli attrezzi di un amministratore Linux, imparare Python è un'ottima scelta come set di abilità.

I maggiori svantaggi di Python a volte sono legati ai suoi punti di forza. Nella storia, Python è stato originariamente progettato per insegnare la programmazione. A volte, le sue basi fondamentali di "facilmente leggibile" e "fare le cose nel modo giusto" possono causare complessità inutili quando si scrive un codice semplice. Inoltre, le sue librerie standard hanno causato problemi durante la transizione dalle versioni 2.X alla 3.X.

Gli script Python sono effettivamente utilizzati al centro di CentOS per funzioni vitali per la funzionalità del sistema operativo. Per questo motivo, è importante isolare il nostro ambiente di sviluppo Python dall'ambiente Python principale di CentOS.

Per i principianti, attualmente ci sono due versioni di Python: Python 2.X e Python 3.X.

Entrambe le fasi sono ancora in produzione attiva, anche se la versione 2.X si sta rapidamente avvicinando all'ammortamento (ed è stato per alcuni anni). La ragione per le due versioni attive di Python era fondamentalmente correggere le carenze della versione 2.X. Ciò richiedeva il ripristino di alcune funzionalità di base della versione 3.X in modi che non potevano supportare alcuni script della versione 2.X.

Fondamentalmente, il modo migliore per superare questa transizione è: Sviluppare per 3.X e tenere il passo con l'ultima versione 2.X per gli script legacy. Attualmente, CentOS 7.X si basa su una revisione semi-corrente della versione 2.X.

Al momento della stesura di questo articolo, le versioni più recenti di Python sono: 3.4.6 e 2.7.13.

Non lasciare che questo confonda o trarre conclusioni su Python. Configurare un ambiente Python è davvero piuttosto semplice. Con i framework e le librerie Python, questa attività è in realtà molto facile da eseguire.

Prima di configurare i nostri ambienti Python, abbiamo bisogno di un ambiente sano. Per iniziare, assicuriamoci che la nostra installazione di CentOS sia completamente aggiornata e installiamo alcune utilità di costruzione.

Step 1 - Aggiorna CentOS.

[root@CentOS]# yum -y update

Step 2 - Installa le utilità di compilazione.

[root@CentOS]# yum -y groupinstall "development tools"

Step 3 - Installa alcuni pacchetti necessari.

[root@CentOS]# yum install -y zlib-dev openssl-devel sqlite-devel bip2-devel

Ora dobbiamo installare le attuali Python 2.X e 3.X dal sorgente.

Scarica archivi compressi
Estrai i file
Compila il codice sorgente

Iniziamo creando una directory di compilazione per ogni installazione di Python in / usr / src /

[root@CentOS]# mkdir -p /usr/src/pythonSource

Ora scarichiamo i tarball dei sorgenti per ciascuno -

[root@CentOS]# wget https://www.python.org/ftp/python/2.7.13/Python-2.7.13.tar.xz
[root@CentOS]# wget https://www.python.org/ftp/python/3.6.0/Python-3.6.0.tar.xz

Ora dobbiamo estrarre ciascuno dall'archivio.

Step 1 - Installa xz-libs ed estrai i tarball.

[root@CentOS]# yum install xz-libs
[root@CentOS python3]# xz -d ./*.xz
[root@CentOS python3]# ls
Python-2.7.13.tar  Python-3.6.0.tar
[root@CentOS python3]#

Step 2 - Decomprimi ogni programma di installazione dal suo tarball.

[root@CentOS]# tar -xvf ./Python-2.7.13.tar
[root@CentOS]# tar -xvf ./Python-3.6.0.tar

Step 3 - Entra in ogni directory ed esegui lo script di configurazione.

[root@CentOS]# ./configure --prefix=/usr/local 
root@CentOS]# make altinstall

Note - Assicurati di usare altinstalle non installare. Ciò manterrà separati CentOS e le versioni di sviluppo di Python. Altrimenti, potresti interrompere la funzionalità di CentOS.

Ora vedrai iniziare il processo di compilazione. Prendi una tazza di caffè e fai una pausa di 15 minuti fino al completamento. Poiché abbiamo installato tutte le dipendenze necessarie per Python, il processo di compilazione dovrebbe essere completato senza errori.

Assicuriamoci di avere l'ultima versione 2.X di Python installata.

[root@CentOS Python-2.7.13]# /usr/local/bin/python2.7 -V 
Python 2.7.13
[root@CentOS Python-2.7.13]#

Note - Dovrai aggiungere il prefisso alla riga shebang che punta al nostro ambiente di sviluppo per Python 2.X.

[root@CentOS Python-2.7.13]# cat ver.py  
#!/usr/local/bin/python2.7 
import sys 
print(sys.version)

[root@CentOS Python-2.7.13]# ./ver.py 
2.7.13 (default, Jan 29 2017, 02:24:08)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)]

Proprio così, abbiamo installazioni Python separate per le versioni 2.X e 3.X. Da qui, possiamo utilizzare ciascuno e utilità comepip e virtualenv per alleviare ulteriormente il peso della gestione degli ambienti Python e dell'installazione dei pacchetti.

Ruby è un ottimo linguaggio sia per lo sviluppo web che per l'amministrazione Linux. Ruby offre molti vantaggi che si trovano in tutti i linguaggi precedenti discussi: PHP, Python e Perl.

Per installare Ruby, è meglio eseguire il bootstrap tramite rbenv che consente agli amministratori di installare e gestire facilmente gli ambienti Ruby.

L'altro metodo per installare Ruby sono i pacchetti CentOS standard per Ruby. Si consiglia di utilizzare il metodo rbenv con tutti i suoi vantaggi. I pacchetti CentOS saranno più facili per i non esperti di Ruby.

Per prima cosa, prendiamo alcune dipendenze necessarie per il programma di installazione di rbenv.

git-core
zlib
zlib-devel
gcc-c++
patch
readline
readline-devel
libyaml-devel
libffi-devel
openssl-devel
make
bzzip2
autoconf
automake
libtool
bison
curl
sqlite-devel

La maggior parte di questi pacchetti potrebbe essere già installata a seconda delle opzioni e dei ruoli scelti durante l'installazione di CentOS. È bene installare tutto ciò di cui non siamo sicuri in quanto ciò può portare a meno mal di testa durante l'installazione di pacchetti che richiedono dipendenze.

[root@CentOS]# yum -y install git-core zlib zlib-devel gcc-c++ patch readline 
readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf 
automake libtool bison curl sqlite-devel

Metodo 1: rbenv per ambienti di sviluppo Dynamic Ruby

Ora come utente che utilizzerà Ruby -

[rdc@CentOS ~]$ git clone https://github.com/rbenv/rbenv.git
[rdc@CentOS ~]$  https://github.com/rbenv/ruby-build.git

ruby-build fornirà funzionalità di installazione a rbenv -

Note- Dobbiamo passare a root o un utente amministratore prima di eseguire install.sh

[rdc@CentOS ruby-build]$ cd ~/ruby-build
[rdc@CentOS ruby-build]# ./install.sh

Impostiamo la nostra shell per rbenv e assicuriamoci di aver installato le opzioni corrette.

[rdc@CentOS ~]$ source ~/rbenv/rbenv.d/exec/gem-rehash.bash [rdc@CentOS ruby-build]$ ~/rbenv/bin/rbenv  
rbenv 1.1.0-2-g4f8925a 
Usage: rbenv <command> [<args>]

Alcuni utili comandi rbenv sono:

Comandi	Azione
Locale	Imposta o mostra la versione Ruby specifica dell'applicazione locale
globale	Imposta o mostra la versione globale di Ruby
conchiglia	Imposta o mostra la versione Ruby specifica della shell
installare	Installa una versione di Ruby usando ruby-build
disinstallare	Disinstalla una versione specifica di Ruby
rimaneggiamento	Rehashes rbenv shims (eseguilo dopo aver installato gli eseguibili)
versione	Mostra la versione corrente di Ruby e la sua origine
versioni	Elenca tutte le versioni di Ruby disponibili per rbenv
quale	Visualizza il percorso completo di un eseguibile
donde	Elenca tutte le versioni di Ruby che contengono il dato eseguibile

Installiamo ora Ruby -

[rdc@CentOS bin]$ ~/rbenv/bin/rbenv install -v 2.2.1

Dopo il completamento della compilazione -

[rdc@CentOS ~]$ ./ruby -v 
ruby 2.2.1p85 (2015-02-26 revision 49769) [x86_64-linux] 
[rdc@CentOS ~]$

Ora abbiamo un ambiente Ruby funzionante con una versione aggiornata e funzionante del ramo Ruby 2.X.

Metodo 2: installa Ruby dai pacchetti CentOS

Questo è il metodo più semplice. Tuttavia, può essere limitato dalla versione e dalle gemme pacchettizzate da CentOS. Per un serio lavoro di sviluppo, si consiglia vivamente di utilizzare il metodo rbenv per installare Ruby.

Installa Ruby, i pacchetti di sviluppo necessari e alcune gemme comuni.

[root@CentOS rdc]# yum install -y ruby.x86_64 ruby-devel.x86_64 ruby-
libs.x86_64 ruby-gem-json.x86_64 rubygem-rake.noarch

Sfortunatamente, ci ritroviamo con una versione un po 'obsoleta di Ruby.

[root@CentOS rdc]# ruby -v 
ruby 2.0.0p648 (2015-12-16) [x86_64-linux]
[root@CentOS rdc]#

Perlè in circolazione da molto tempo. È stato originariamente progettato come linguaggio di reporting utilizzato per analizzare i file di testo. Con una maggiore popolarità, Perl ha aggiunto un supporto per moduli o CPAN, socket, threading e altre funzionalità necessarie in un potente linguaggio di scripting.

Il più grande vantaggio di Perl rispetto a PHP, Python o Ruby è: fa le cose con il minimo sforzo. Questa filosofia di Perl non significa sempre che le cose vengano fatte nel modo giusto. Tuttavia, per le attività di amministrazione su Linux, Perl è considerata la scelta ideale per un linguaggio di scripting.

Alcuni vantaggi di Perl rispetto a Python o Ruby sono:

Potente elaborazione del testo
Perl rende la scrittura di script rapida e sporca (di solito uno script Perl sarà diverse dozzine di righe più corte di un equivalente in Python o Ruby)
Perl può fare qualsiasi cosa (quasi)

Alcuni svantaggi di Perl sono:

La sintassi può creare confusione
Lo stile di codifica in Perl può essere unico e ostacolare la collaborazione
Perl non è realmente orientato agli oggetti
In genere, non c'è molto da pensare alla standardizzazione e alle migliori pratiche quando viene utilizzato Perl.

Quando si decide se utilizzare Perl, Python o PHP; dovrebbero essere poste le seguenti domande:

Questa applicazione avrà mai bisogno del controllo delle versioni?
Altre persone avranno mai bisogno di modificare il codice?
Altre persone avranno bisogno di utilizzare questa applicazione?
Questa applicazione verrà mai utilizzata su un'altra macchina o su un'altra architettura della CPU?

Se le risposte a tutte le domande precedenti sono "no", Perl è una buona scelta e può accelerare le cose in termini di risultati finali.

Detto questo, configuriamo il nostro server CentOS per utilizzare la versione più recente di Perl.

Prima di installare Perl, è necessario comprendere il supporto per Perl. Ufficialmente, Perl è supportato solo dalle ultime due versioni stabili. Quindi, vogliamo essere sicuri di mantenere il nostro ambiente di sviluppo isolato dalla versione CentOS.

La ragione dell'isolamento è: se qualcuno rilascia uno strumento in Perl alla comunità CentOS, molto probabilmente verrà modificato per funzionare su Perl come fornito con CentOS. Tuttavia, vogliamo anche avere l'ultima versione installata per scopi di sviluppo. Come Python, CentOS spedisce Perl focalizzato sull'affidabilità e non sull'avanguardia.

Controlliamo la nostra attuale versione di Perl su CentOS 7.

[root@CentOS]# perl -v 
This is perl 5, version 16, subversion 3 (v5.16.3) built for x86_64-linux-thread-multi

Attualmente stiamo eseguendo Perl 5.16.3. La versione più recente al momento della stesura di questo articolo è: perl-5.24.0

Vogliamo sicuramente aggiornare la nostra versione, essendo in grado di utilizzare moduli Perl aggiornati nel nostro codice. Fortunatamente, esiste un ottimo strumento per mantenere gli ambienti Perl e mantenere isolata la nostra versione CentOS di Perl. È chiamatoperlbrew.

Installiamo Perl Brew.

[root@CentOS]# curl -L https://install.perlbrew.pl | bash 
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current 
                             Dload  Upload   Total   Spent    Left  Speed 
100   170  100   170    0     0    396      0 --:--:-- --:--:-- --:--:--   397 
100  1247  100  1247    0     0   1929      0 --:--:-- --:--:-- --:--:--  1929

Ora che abbiamo installato Perl Brew, creiamo un ambiente per l'ultima versione di Perl.

Per prima cosa, avremo bisogno della versione di Perl attualmente installata per avviare l'installazione di perlbrew. Quindi, prendiamo alcuni moduli Perl necessari dal repository CentOS.

Note - Quando disponibili, desideriamo sempre utilizzare i moduli Perl CentOS rispetto a CPAN con la nostra installazione Perl CentOS.

Step 1 - Installa il modulo CentOS Perl Make :: Maker.

[root@CentOS]# yum -y install perl-ExtUtils-MakeMaker.noarch

Step 2 - Installa l'ultima versione di perl.

[root@CentOS build]# source ~/perl5/perlbrew/etc/bashrc
[root@CentOS build]# perlbrew install -n -j4 --threads perl-5.24.1

Le opzioni che abbiamo scelto per la nostra installazione di Perl sono:

n - Nessun test
j4 - Esegui 4 thread in parallelo per le routine di installazione (stiamo usando una CPU quadcore)
threads - Abilita il supporto del threading per Perl

Dopo che la nostra installazione è stata eseguita con successo, passiamo al nostro ambiente Perl più recente.

[root@CentOS]# ~/perl5/perlbrew/bin/perlbrew use perl-5.24.1

A sub-shell is launched with perl-5.24.1 as the activated perl. Run 'exit' to finish it.

[root@CentOS]# perl -v

This is perl 5, version 24, subversion 1 (v5.24.1) built for x86_64-linuxthread-multi

(with 1 registered patch, see perl -V for more detail)

Copyright 1987-2017, Larry Wall

Perl may be copied only under the terms of either the Artistic License or the GNU General
Public License, which may be found in the Perl 5 source kit.

Complete documentation for Perl, including FAQ lists, should be found on this system 
using "man perl" or "perldoc perl".  If you have access to the Internet, point your 
browser at http://www.perl.org/, the Perl Home Page.

[root@CentOS]#

Semplice stampa di script perl versione di perl in esecuzione nel contesto del nostro ambiente perlbrew -

[root@CentOS]# cat ./ver.pl  
#!/usr/bin/perl
print $^V . "\n";

[root@CentOS]# perl ./ver.pl  
v5.24.1 
[root@CentOS]#

Una volta installato perl, possiamo caricare i moduli cpan con cpanm di perl brew -

[root@CentOS]# perl-brew install-cpanm

Ora usiamo l' installatore cpanm per creare il modulo LWP con la nostra attuale versione Perl di 5.24.1 in perl brew.

Step 1 - Passa al contesto della nostra attuale versione Perl.

[root@CentOS ~]# ~/perl5/perlbrew/bin/perlbrew use perl-5.24.1

Viene lanciata una sub-shell con perl-5.24.1 come perl attivato. Esegui "exit" per finirlo.

[root@CentOS ~]#

Step 2 - Installa LWP User Agent Perl Module.

[root@CentOS ~]# ~/perl5/perlbrew/bin/cpanm -i LWP::UserAgent

Step 3 - Ora testiamo il nostro ambiente Perl con il nuovo modulo CPAN.

[root@CentOS ~]# cat ./get_header.pl  
#!/usr/bin/perl 
use LWP; 
my $browser = LWP::UserAgent->new(); my $response = $browser->get("http://www.slcc.edu/"); unless(!$response->is_success) { 
   print $response->header("Server"); 
}

[root@CentOS ~]# perl ./get_header.pl  
Microsoft-IIS/8.5 [root@CentOS ~]#

Ecco qui! Perl Brew rende l'isolamento degli ambienti Perl un gioco da ragazzi e può essere considerato come una best practice man mano che le cose si fanno con Perl.

LDAP noto come Light Weight Directory Access Protocolè un protocollo utilizzato per accedere ai contenitori di servizi X.500 all'interno di un'azienda nota da una directory. Coloro che hanno familiarità con Windows Server Administration possono pensare a LDAP come di natura molto simile ad Active Directory. È anche un concetto ampiamente utilizzato di intrecciare workstation Windows in un'impresa OpenLDAP CentOS. D'altro canto, una workstation CentOS Linux può condividere risorse e partecipare con le funzionalità di base in un dominio Windows.

La distribuzione di LDAP su CentOS come agente server di directory, agente di sistema directory o DSA (questi acronimi sono tutti uguali) è simile alle installazioni Novell Netware precedenti che utilizzano la struttura ad albero delle directory con NDS.

Breve storia di LDAP

LDAP è stato fondamentalmente creato come un modo efficiente per accedere alle directory X.500 con le risorse aziendali. Sia X.500 che LDAP condividono le stesse caratteristiche e sono così simili che i client LDAP possono accedere alle directory X.500 con alcuni helper. Sebbene LDAP abbia anche il proprio server di directory chiamatoslapd. La principale differenza tra LDAP e DAP è che la versione leggera è progettata per funzionare su TCP.

Mentre DAP utilizza il modello OSI completo. Con l'avvento di Internet, TCP / IP ed Ethernet prominenza nelle reti odierne, è raro imbattersi in un impianto di Directory Services utilizzando directory aziendali sia DAP che native X.500 al di fuori di specifici modelli di elaborazione legacy.

I componenti principali utilizzati con openldap per CentOS Linux sono:

openldap	Librerie di supporto LDAP
openldap-server	Server LDAP
client-openldap	Utilità client LDAP
openldap-devel	Librerie di sviluppo per OpenLDAP
compay-openldap	Librerie condivise OpenLDAP
slapd	Demone del server di directory di OpenLDAP
slurpd	Utilizzato per la replica LDAP in un dominio aziendale

Note - Quando si nomina la propria azienda, è consigliabile utilizzare l'estensione .localTLD. L'utilizzo di un .net o .com può causare difficoltà quando si separa un'infrastruttura di dominio online e interna. Immagina il lavoro extra per un'azienda che utilizza internamente acme.com sia per operazioni esterne che interne. Quindi, può essere saggio avere risorse Internet chiamate acme.com o acme.net . Quindi, le risorse aziendali di rete locale vengono rappresentate come acme.local . Ciò comporterà la configurazione dei record DNS, ma pagherà in semplicità, eloquenza e sicurezza.

Installa Open LDAP su CentOS

Installa openldap, openldap-servers, openldap-clients e migrationstools da YUM .

[root@localhost]# yum -y install openldap openldap-servers openldap-clients
migration tools
 Loaded plugins: fastestmirror, langpacks
 updates
 | 3.4 kB  00:00:00
 updates/7/x86_64/primary_db
 | 2.2 MB  00:00:05
 Determining fastest mirrors
 (1/2): extras/7/x86_64/primary_db
 | 121 kB  00:00:01
 (2/2): base/7/x86_64/primary_db
 | 5.6 MB  00:00:16
 Package openldap-2.4.40-13.el7.x86_64 already installed and latest version
 Resolving Dependencies
 --> Running transaction check
 ---> Package openldap-clients.x86_64 0:2.4.40-13.el7 will be installed
 ---> Package openldap-servers.x86_64 0:2.4.40-13.el7 will be installed
 --> Finished Dependency Resolution
 base/7/x86_64/group_gz
 | 155 kB  00:00:00
 
 Dependencies Resolved
 
=============================================================================== 
=============================================================================== 
Package                                Arch
Version                             Repository                        Size 
=============================================================================== 
=============================================================================== 
Installing: 
openldap-clients                    x86_64
2.4.40-13.el7                    base                                 188 k 
openldap-servers                    x86_64
2.4.40-13.el7                    base                                 2.1 M  

Transaction Summary 
=============================================================================== 
===============================================================================
Install  2 Packages

Total download size: 2.3 M 
Installed size: 5.3 M 
Downloading packages:

Installed: 
openldap-clients.x86_64 0:2.4.40-13.el7                                       
openldap-servers.x86_64 0:2.4.40-13.el7                                       
Complete! 
[root@localhost]#

Ora iniziamo e abilitiamo il servizio slapd -

[root@centos]# systemctl start slapd 
[root@centos]# systemctl enable  slapd

A questo punto, assicuriamoci di avere la nostra struttura openldap in / etc / openldap .

root@localhost]# ls /etc/openldap/ 
certs  check_password.conf  ldap.conf  schema  slapd.d
[root@localhost]#

Quindi assicurati che il nostro servizio slapd sia in esecuzione.

root@centos]# netstat -antup | grep slapd
tcp        0      0 0.0.0.0:389            0.0.0.0:*              LISTEN      1641/slapd
tcp6       0      0 :::389                 :::*                   LISTEN      1641/slapd
 
[root@centos]#

Successivamente, configuriamo la nostra installazione Open LDAP .

Assicurati che il nostro utente ldap di sistema sia stato creato.

[root@localhost]# id ldap 
uid=55(ldap) gid=55(ldap) groups=55(ldap)
[root@localhost]#

Genera le nostre credenziali LDAP.

[root@localhost]# slappasswd  
New password:  
Re-enter new password:  
{SSHA}20RSyjVv6S6r43DFPeJgASDLlLoSU8g.a10

[root@localhost]#

Dobbiamo salvare l'output da slappasswd.

Configurare Open LDAP

Step 1 - Configurare LDAP per il dominio e aggiungere l'utente amministrativo.

Innanzitutto, vogliamo configurare il nostro ambiente openLDAP. Di seguito è riportato un modello da utilizzare con il comando ldapmodify .

dn: olcDatabase={2}hdb,cn=config 
changetype: modify 
replace: olcSuffix 
olcSuffix: dc=vmnet,dc=local 
dn: olcDatabase = {2}hdb,cn=config 
changetype: modify 
replace: olcRootDN 
olcRootDN: cn=ldapadm,dc=vmnet,dc=local 
dn: olcDatabase = {2}hdb,cn=config 
changetype: modify 
replace: olcRootPW 
olcRootPW: <output from slap

Apporta le modifiche a: /etc/openldap/slapd.d/cn=config/olcDatabase = {1} monitor.ldif con il comando ldapmodify.

[root@localhost]# ldapmodify -Y EXTERNAL -H ldapi:/// -f /home/rdc/Documents/db.ldif  
SASL/EXTERNAL authentication started 
SASL username: gidNumber = 0+uidNumber = 0,cn=peercred,cn=external,cn=auth 
SASL SSF: 0 
modifying entry "olcDatabase = {2}hdb,cn=config" 
modifying entry "olcDatabase = {2}hdb,cn=config" 
modifying entry "olcDatabase = {2}hdb,cn=config" 

[root@localhost cn=config]#

Controlliamo la configurazione LDAP modificata.

root@linux1 ~]# vi /etc/openldap/slapd.d/cn=config/olcDatabase={2}hdb.ldif

[root@centos]# cat /etc/openldap/slapd.d/cn\=config/olcDatabase\=\{2\}hdb.ldif
 # AUTO-GENERATED FILE - DO NOT EDIT!! Use ldapmodify. 
 # CRC32 a163f14c
dn: olcDatabase = {2}hdb
objectClass: olcDatabaseConfig
objectClass: olcHdbConfig
olcDatabase: {2}hdb
olcDbDirectory: /var/lib/ldap
olcDbIndex: objectClass eq,pres
olcDbIndex: ou,cn,mail,surname,givenname eq,pres,sub
structuralObjectClass: olcHdbConfig
entryUUID: 1bd9aa2a-8516-1036-934b-f7eac1189139
creatorsName: cn=config
createTimestamp: 20170212022422Z
olcSuffix: dc=vmnet,dc=local
olcRootDN: cn=ldapadm,dc=vmnet,dc=local
olcRootPW:: e1NTSEF1bUVyb1VzZTRjc2dkYVdGaDY0T0k = 
entryCSN: 20170215204423.726622Z#000000#000#000000 
modifiersName: gidNumber = 0+uidNumber = 0,cn=peercred,cn=external,cn=auth
modifyTimestamp: 20170215204423Z

[root@centos]#

Come puoi vedere, le nostre modifiche aziendali LDAP hanno avuto successo.

Successivamente, vogliamo creare un certificato SSL autofirmato per OpenLDAP. Ciò proteggerà la comunicazione tra il server aziendale e i client.

Step 2 - Crea un certificato autofirmato per OpenLDAP.

Useremo openssl per creare un certificato SSL autofirmato. Vai al capitolo successivo,Create LDAP SSL Certificate with opensslper istruzioni su come proteggere le comunicazioni con OpenLDAP. Quindi, quando i certificati ssl saranno configurati, avremo completato la nostra configurazione aziendale OpenLDAP.

Step 3 - Configurare OpenLDAP per utilizzare comunicazioni protette con certificato.

Crea un file certs.ldif in vim con le seguenti informazioni:

dn: cn=config
changetype: modify
replace: olcTLSCertificateFile
olcTLSCertificateFile: /etc/openldap/certs/yourGeneratedCertFile.pem

dn: cn=config
changetype: modify
replace: olcTLSCertificateKeyFile
olcTLSCertificateKeyFile: /etc/openldap/certs/youGeneratedKeyFile.pem

Quindi, ancora una volta, usa il comando ldapmodify per unire le modifiche alla configurazione di OpenLDAP.

[root@centos rdc]# ldapmodify -Y EXTERNAL  -H ldapi:/// -f certs.ldif
SASL/EXTERNAL authentication started
SASL username: gidNumber = 0+uidNumber = 0,cn=peercred,cn=external,cn=auth
SASL SSF: 0
modifying entry "cn=config"

[root@centos]#

Infine, testiamo la nostra configurazione OpenLADP.

[root@centos]# slaptest -u 
config file testing succeeded 
[root@centos]#

Step 4 - Imposta il database slapd.

cp /usr/share/openldap-servers/DB_CONFIG.example /var/lib/ldap/DB_CONFIG && 
chown ldap:ldap /var/lib/ldap/*

Aggiorna lo schema OpenLDAP.

Aggiungi gli schemi LDAP coseno e nis.

ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/cosine.ldif
ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/nis.ldif
ldapadd -Y EXTERNAL -H ldapi:/// -f /etc/openldap/schema/inetorgperson.ldif

Infine, crea lo schema aziendale e aggiungilo alla configurazione OpenLDAP corrente.

Quello che segue è per un dominio chiamato vmnet. local con un amministratore LDAP chiamato ldapadm .

dn: dc=vmnet,dc=local
dc: vmnet
objectClass: top
objectClass: domain

dn: cn=ldapadm ,dc=vmnet,dc=local
objectClass: organizationalRole
cn: ldapadm
description: LDAP Manager

dn: ou = People,dc=vmnet,dc=local
objectClass: organizationalUnit
ou: People

dn: ou = Group,dc=vmnet,dc=local 
objectClass: organizationalUnit 
ou: Group

Infine, importalo nello schema OpenLDAP corrente.

[root@centos]# ldapadd -x -W -D "cn=ldapadm,dc=vmnet,dc=local" -f ./base.ldif
 Enter LDAP Password:
adding new entry "dc=vmnet,dc=local"

adding new entry "cn=ldapadm ,dc=vmnet,dc=local"

adding new entry "ou=People,dc=vmnet,dc=local"

adding new entry "ou=Group,dc=vmnet,dc=local"

[root@centos]#

Step 5 - Configurare un utente OpenLDAP Enterprise.

Apri vim o il tuo editor di testo preferito e copia il seguente formato. Questo è configurato per un utente denominato "entacct" nel dominio LDAP "vmnet.local".

dn: uid=entacct,ou=People,dc=vmnet,dc=local 
objectClass: top
objectClass: account 
objectClass: posixAccount 
objectClass: shadowAccount 
cn: entacct 
uid: entacct 
uidNumber: 9999 
gidNumber: 100 
homeDirectory: /home/enyacct 
loginShell: /bin/bash 
gecos: Enterprise User Account 001 
userPassword: {crypt}x 
shadowLastChange: 17058 
shadowMin: 0 
shadowMax: 99999 
shadowWarning: 7

Ora importa i file sopra, come salvati, nello schema OpenLdap.

[root@centos]# ldapadd -x -W -D "cn=ldapadm,dc=vmnet,dc=local" -f entuser.ldif 
 Enter LDAP Password:
adding new entry "uid=entacct,ou=People,dc=vmnet,dc=local" 

[root@centos]#

Prima che gli utenti possano accedere a LDAP Enterprise, è necessario assegnare una password come segue:

ldappasswd -s password123 -W -D "cn=ldapadm,dc=entacct,dc=local" -x "uid=entacct 
,ou=People,dc=vmnet,dc=local"

-s specifica la password per l'utente

-x è il nome utente a cui viene applicata la password aggiornata

-D è il * distinguished name "per l'autenticazione rispetto allo schema LDAP.

Infine, prima di accedere all'account Enterprise, controlliamo la nostra voce OpenLDAP .

[root@centos rdc]# ldapsearch -x cn=entacct -b dc=vmnet,dc=local
 # extended LDIF
 #
 # LDAPv3
 # base <dc=vmnet,dc=local> with scope subtree
 # filter: cn=entacct
 # requesting: ALL 
 # 
 # entacct, People, vmnet.local 
dn: uid=entacct,ou=People,dc=vmnet,dc=local 
objectClass: top 
objectClass: account 
objectClass: posixAccount 
objectClass: shadowAccount 
cn: entacct 
uid: entacct 
uidNumber: 9999 
gidNumber: 100 
homeDirectory: /home/enyacct 
loginShell: /bin/bash 
gecos: Enterprise User Account 001 
userPassword:: e2NyeXB0fXg= 
shadowLastChange: 17058 
shadowMin: 0 
shadowMax: 99999 
shadowWarning: 7

La conversione di cose come / etc / passwd e / etc / groups nell'autenticazione OpenLDAP richiede l'uso di strumenti di migrazione. Questi sono inclusi nel pacchetto migrationtools . Quindi, installato in / usr / share / migrationtools .

[root@centos openldap-servers]# ls -l /usr/share/migrationtools/
total 128
-rwxr-xr-x. 1 root root  2652 Jun  9  2014 migrate_aliases.pl
-rwxr-xr-x. 1 root root  2950 Jun  9  2014 migrate_all_netinfo_offline.sh
-rwxr-xr-x. 1 root root  2946 Jun  9  2014 migrate_all_netinfo_online.sh
-rwxr-xr-x. 1 root root  3011 Jun  9  2014 migrate_all_nis_offline.sh
-rwxr-xr-x. 1 root root  3006 Jun  9  2014 migrate_all_nis_online.sh
-rwxr-xr-x. 1 root root  3164 Jun  9  2014 migrate_all_nisplus_offline.sh
-rwxr-xr-x. 1 root root  3146 Jun  9  2014 migrate_all_nisplus_online.sh
-rwxr-xr-x. 1 root root  5267 Jun  9  2014 migrate_all_offline.sh
-rwxr-xr-x. 1 root root  7468 Jun  9  2014 migrate_all_online.sh
-rwxr-xr-x. 1 root root  3278 Jun  9  2014 migrate_automount.pl
-rwxr-xr-x. 1 root root  2608 Jun  9  2014 migrate_base.pl

Step 6 - Infine, dobbiamo consentire l'accesso al servizio slapd in modo che possa soddisfare le richieste.

firewall-cmd --permanent --add-service=ldap 
firewall-cmd --reload

Configurare l'accesso client LDAP

La configurazione dell'accesso al client LDAP richiede i seguenti pacchetti sul client: openldap, open-ldap clients e nss_ldap.

La configurazione dell'autenticazione LDAP per i sistemi client è un po 'più semplice.

Step 1 - Installa pacchetti dipendenti -

# yum install -y openldap-clients nss-pam-ldapd

Step 2- Configurare l'autenticazione LDAP con authconfig .

authconfig --enableldap --enableldapauth --ldapserver=10.25.0.1 --
ldapbasedn="dc=vmnet,dc=local" --enablemkhomedir --update

Step 3 - Riavvia il servizio nslcd.

systemctl restart  nslcd

Sfondo TLS e SSL

TLS è il nuovo standard per la sicurezza del livello socket, che procede con SSL. TLS offre standard di crittografia migliori con altre funzionalità di protezione e wrapper di protocollo che migliorano SSL. Spesso i termini TLS e SSL vengono utilizzati in modo intercambiabile. Tuttavia, in qualità di amministratore CentOS professionale, è importante notare le differenze e la cronologia che li separa.

SSL va fino alla versione 3.0. SSL è stato sviluppato e promosso come standard industriale sotto Netscape. Dopo che Netscape è stato acquistato da AOL (un ISP popolare negli anni '90 altrimenti noto come America Online), AOL non ha mai veramente promosso il cambiamento necessario per i miglioramenti della sicurezza a SSL.

Alla versione 3.1, la tecnologia SSL è passata agli standard dei sistemi aperti ed è stata modificata in TLS . Poiché i diritti d'autore su SSL erano ancora di proprietà di AOL, è stato coniato un nuovo termine:TLS - Transport Layer Security. Quindi è importante riconoscere che TLS è in realtà diverso da SSL . Soprattutto, poiché le tecnologie SSL meno recenti presentano problemi di sicurezza noti e alcune sono considerate obsolete oggi.

Note- Questo tutorial utilizzerà il termine TLS quando si parla di tecnologie 3.1 e successive. Quindi SSL quando si commentano specifici per le tecnologie SSL 3.0 e precedenti.

Controllo delle versioni SSL vs TLS

La tabella seguente mostra come il controllo delle versioni TLS e SSL si relazionerebbero tra loro. Ho sentito alcune persone parlare in termini di SSL versione 3.2. Tuttavia, probabilmente hanno ottenuto la terminologia dalla lettura di un blog. In qualità di amministratore professionista, desideriamo sempre utilizzare la terminologia standard. Quindi, mentre si parla, SSL dovrebbe essere un riferimento alle tecnologie del passato. Le cose semplici possono far sembrare un cercatore di lavoro CentOS un CS Major esperto.

TLS	SSL
-	3.0
1.0	3.1
1.1	3.2
1.2	3.3

TLS svolge due funzioni principali importanti per gli utenti di Internet oggi: Uno, verifica chi è una parte, nota comeauthentication. Due, offreend-to-end encryption a livello di trasporto per i protocolli di livello superiore che non dispongono di questa funzionalità nativa (ftp, http, protocolli di posta elettronica e altro).

Il primo, verifica chi è una parte ed è importante per la sicurezza come crittografia end-to-end. Se un consumatore dispone di una connessione crittografata a un sito Web non autorizzato a ricevere pagamenti, i dati finanziari sono ancora a rischio. Questo è ciò che ogni sito di phishing non avrà:a properly signed TLS certificate verifying website operators are who they claim to be from a trusted CA.

Esistono solo due metodi per aggirare la mancanza di un certificato firmato correttamente: indurre l'utente a consentire la fiducia di un browser Web per un certificato autofirmato o sperare che l'utente non sia esperto di tecnologia e non conoscerà l'importanza di un certificato affidabile Autorità (o CA).

In questo tutorial, useremo quello che è conosciuto come un auto-firmato il certificato. Ciò significa che, senza fornire esplicitamente a questo certificato lo stato di attendibile in ogni browser Web che visita il sito Web, verrà visualizzato un errore che scoraggia gli utenti dal visitare il sito. Quindi, farà saltare all'utente alcune azioni prima di accedere a un sito con un certificato autofirmato. Ricorda, per motivi di sicurezza, che questa è una buona cosa.

Installa e configura openssl

openssl è lo standard per le implementazioni open source di TLS. openssl è utilizzato su sistemi come Linux, distribuzioni BSD, OS X e supporta anche Windows.

openssl è importante, poiché fornisce sicurezza a livello di trasporto e astrae la programmazione dettagliata dell'autenticazione e della crittografia end-to-end per uno sviluppatore. Questo è il motivo per cui openssl viene utilizzato con quasi tutte le singole applicazioni open source che utilizzano TLS. Inoltre è installato di default su ogni versione moderna di Linux.

Per impostazione predefinita, openssl dovrebbe essere installato su CentOS almeno dalla versione 5 in poi. Giusto per assicurarti, proviamo a installare openssl tramite YUM. Basta eseguire l'installazione, poiché YUM è abbastanza intelligente da farci sapere se un pacchetto è già installato. Se stiamo eseguendo una versione precedente di CentOS per motivi di compatibilità, eseguire un'installazione yum -y assicurerà che openssl sia aggiornato contro la vulnerabilità semi-recente heart-bleed.

Durante l'esecuzione del programma di installazione, è stato rilevato che in realtà era presente un aggiornamento a openssl .

[root@centos]# yum -y install openssl
Resolving Dependencies
--> Running transaction check
---> Package openssl.x86_64 1:1.0.1e-60.el7 will be updated
---> Package openssl.x86_64 1:1.0.1e-60.el7_3.1 will be an update
--> Processing Dependency: openssl-libs(x86-64) = 1:1.0.1e-60.el7_3.1 for 
package: 1:openssl-1.0.1e-60.el7_3.1.x86_64
--> Running transaction check
---> Package openssl-libs.x86_64 1:1.0.1e-60.el7 will be updated
---> Package openssl-libs.x86_64 1:1.0.1e-60.el7_3.1 will be an update
--> Finished Dependency Resolution 
Dependencies Resolved

===============================================================================
=============================================================================== 
 Package                               Arch
 Version                            Repository                        Size 
=============================================================================== 
=============================================================================== 
Updating: 
openssl                               x86_64                          
1:1.0.1e-60.el7_3.1                 updates                           713 k
Updating for dependencies:

Crea certificato autofirmato per OpenLDAP

Questo è un metodo per creare un auto-firmato per la nostra precedente installazione di OpenLDAP .

Per creare un certificato OpenLDAP autofirmato.

openssl req -new -x509 -nodes -out /etc/openldap/certs/myldaplocal.pem -keyout
/etc/openldap/certs/myldaplocal.pem -days 365

[root@centos]# openssl req -new -x509 -nodes -out /etc/openldap/certs/vmnet.pem 
-keyout /etc/openldap/certs/vmnet.pem -days 365 
Generating a 2048 bit RSA private key
.............................................+++
................................................+++
writing new private key to '/etc/openldap/certs/vmnet.pem'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [XX]:US
State or Province Name (full name) []:Califonia
Locality Name (eg, city) [Default City]:LA
Organization Name (eg, company) [Default Company Ltd]:vmnet
Organizational Unit Name (eg, section) []:
Common Name (eg, your name or your server's hostname) []:centos
Email Address []:[email protected]
[root@centos]#

Ora i nostri certificati OpenLDAP dovrebbero essere inseriti in / etc / openldap / certs /

[root@centos]# ls /etc/openldap/certs/*.pem 
/etc/openldap/certs/vmnetcert.pem  /etc/openldap/certs/vmnetkey.pem
[root@centos]#

Come puoi vedere, abbiamo sia il certificato che la chiave installati nelle directory / etc / openldap / certs / . Infine, dobbiamo modificare le autorizzazioni per ciascuno, poiché sono attualmente di proprietà dell'utente root.

[root@centos]# chown -R  ldap:ldap /etc/openldap/certs/*.pem
[root@centos]# ls -ld /etc/openldap/certs/*.pem
-rw-r--r--. 1 ldap ldap 1395 Feb 20 10:00 /etc/openldap/certs/vmnetcert.pem 
-rw-r--r--. 1 ldap ldap 1704 Feb 20 10:00 /etc/openldap/certs/vmnetkey.pem
[root@centos]#

Crea certificato autofirmato per Apache Web Server

In questo tutorial, supporremo che Apache sia già installato. Abbiamo installato Apache in un altro tutorial (configurazione di CentOS Firewall) e andremo all'installazione avanzata di Apache per un futuro tutorial. Quindi, se non hai già installato Apache, segui.

Una volta che Apache HTTPd può essere installato utilizzando i seguenti passaggi:

Step 1 - Installa mod_ssl per il server httpd Apache.

Per prima cosa dobbiamo configurare Apache con mod_ssl. Usare il gestore di pacchetti YUM è piuttosto semplice -

[root@centos]# yum -y install mod_ssl

Quindi ricarica il tuo demone Apache per assicurarti che Apache utilizzi la nuova configurazione.

[root@centos]# systemctl reload httpd

A questo punto, Apache è configurato per supportare le connessioni TLS sull'host locale.

Step 2 - Crea il certificato SSL autofirmato.

Per prima cosa, configuriamo la nostra directory delle chiavi TLS private.

[root@centos]# mkdir /etc/ssl/private 
[root@centos]# chmod 700 /etc/ssl/private/

Note- Assicurati che solo la root abbia accesso in lettura / scrittura a questa directory. Con l'accesso in lettura / scrittura mondiale, la tua chiave privata può essere utilizzata per decrittografare il traffico rilevato.

Generazione del certificato e dei file chiave.

[root@centos]# sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout 
/etc/ssl/private/self-gen-apache.key -out /etc/ssl/certs/self-sign-apache.crt 
Generating a 2048 bit RSA private key
..........+++
....+++
-----
Country Name (2 letter code) [XX]:US
State or Province Name (full name) []:xx
Locality Name (eg, city) [Default City]:xxxx
Organization Name (eg, company) [Default Company Ltd]:VMNET
Organizational Unit Name (eg, section) []:
Common Name (eg, your name or your server's hostname) []:centos.vmnet.local
Email Address []:

[root@centos]#

Note - Puoi utilizzare l'indirizzo IP pubblico del server se non hai un nome di dominio registrato.

Diamo un'occhiata al nostro certificato -

[root@centos]# openssl x509 -in self-sign-apache.crt -text -noout
Certificate:
   Data:
      Version: 3 (0x2)
      Serial Number: 17620849408802622302 (0xf489d52d94550b5e)
   Signature Algorithm: sha256WithRSAEncryption
   Issuer: C=US, ST=UT, L=xxxx, O=VMNET, CN=centos.vmnet.local
   Validity
      Not Before: Feb 24 07:07:55 2017 GMT
      Not After : Feb 24 07:07:55 2018 GMT
   Subject: C=US, ST=UT, L=xxxx, O=VMNET, CN=centos.vmnet.local
   Subject Public Key Info:
      Public Key Algorithm: rsaEncryption
         Public-Key: (2048 bit)
            Modulus:
               00:c1:74:3e:fc:03:ca:06:95:8d:3a:0b:7e:1a:56:
               f3:8d:de:c4:7e:ee:f9:fa:79:82:bf:db:a9:6d:2a:
               57:e5:4c:31:83:cf:92:c4:e7:16:57:59:02:9e:38:
               47:00:cd:b8:31:b8:34:55:1c:a3:5d:cd:b4:8c:b0:
               66:0c:0c:81:8b:7e:65:26:50:9d:b7:ab:78:95:a5:
               31:5e:87:81:cd:43:fc:4d:00:47:5e:06:d0:cb:71:
               9b:2a:ab:f0:90:ce:81:45:0d:ae:a8:84:80:c5:0e:
               79:8a:c1:9b:f4:38:5d:9e:94:4e:3a:3f:bd:cc:89:
               e5:96:4a:44:f5:3d:13:20:3d:6a:c6:4d:91:be:aa:
               ef:2e:d5:81:ea:82:c6:09:4f:40:74:c1:b1:37:6c:
               ff:50:08:dc:c8:f0:67:75:12:ab:cd:8d:3e:7b:59:
               e0:83:64:5d:0c:ab:93:e2:1c:78:f0:f4:80:9e:42: 
               7d:49:57:71:a2:96:c6:b8:44:16:93:6c:62:87:0f:
               5c:fe:df:29:89:03:6e:e5:6d:db:0a:65:b2:5e:1d:
               c8:07:3d:8a:f0:6c:7f:f3:b9:32:b4:97:f6:71:81:
               6b:97:e3:08:bd:d6:f8:19:40:f1:15:7e:f2:fd:a5:
               12:24:08:39:fa:b6:cc:69:4e:53:1d:7e:9a:be:4b:

Ecco una spiegazione per ogni opzione che abbiamo usato con il comando openssl :

Comando	Azione
req -X509	Utilizzare lo standard PKI di gestione CSR X.509 per la gestione delle chiavi.
-nodi	Non proteggere il nostro certificato con una passphrase. Apache deve essere in grado di utilizzare il certificato senza l'interruzione di una passphrase.
-giorni 2555	Indica la validità del certificato a 7 anni o 2555 giorni. Il periodo di tempo può essere regolato secondo necessità.
-newkey rsa: 2048	Specificato per generare sia la chiave che il certificato utilizzando RSA a 2048 bit di lunghezza.

Successivamente, vogliamo creare un gruppo Diffie-Heliman per la negoziazione di PFS con i clienti.

[centos#] openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

Questo richiederà da 5 a 15 minuti.

Perfect Forward Secrecy- Utilizzato per proteggere i dati della sessione nel caso in cui la chiave privata sia stata compromessa. Questo genererà una chiave utilizzata tra il client e il server che è unica per ogni sessione.

Ora aggiungi la configurazione Perfect Forward Secrecy al nostro certificato.

[root@centos]# cat /etc/ssl/certs/dhparam.pem | tee -a /etc/ssl/certs/self-sign-apache.crt

Configurare Apache per utilizzare file di chiavi e certificati

Apporteremo modifiche a /etc/httpd/conf.d/ssl.conf -

Apporteremo le seguenti modifiche a ssl.conf . Tuttavia, prima di farlo dovremmo eseguire il backup del file originale. Quando si apportano modifiche a un server di produzione in un editor di testo avanzato come vi o emcas , è consigliabile eseguire sempre il backup dei file di configurazione prima di apportare modifiche.

[root@centos]# cp /etc/httpd/conf.d/ssl.conf ~/

Ora continuiamo le nostre modifiche dopo aver copiato una copia funzionante di ssl.conf nella root della nostra cartella home.

Locate
Modificare sia DocumentRoot che ServerName come segue.

\\# General setup for the virtual host, inherited from global configuration
DocumentRoot "/var/www/html"
ServerName centos.vmnet.local:443

DocumentRootquesto è il percorso della directory predefinita di apache. In questa cartella dovrebbe esserci una pagina predefinita che visualizzerà una richiesta HTTP che richiede la pagina predefinita del tuo server web o sito.

ServerNameè il nome del server che può essere un indirizzo IP o il nome host del server. Per TLS, è consigliabile creare un certificato con un nome host. Dal nostro tutorial OpenLdap, abbiamo creato un hostname di centos sul dominio aziendale locale: vmnet.local

Ora vogliamo commentare le seguenti righe.

SSLProtocol

#   SSL Protocol support:
# List the enable protocol levels with which clients will be able to
# connect.  Disable SSLv2 access by default:
 ~~~~> #SSLProtocol all -SSLv2
 
#   SSL Cipher Suite:
#   List the ciphers that the client is permitted to negotiate.
#   See the mod_ssl documentation for a complete list.
 ~~~~> #SSLCipherSuite HIGH:MEDIUM:!aNULL:!MD5:!SEED:!IDEA

Quindi fai sapere ad Apache dove trovare il nostro certificato e la coppia di chiavi pubblica / privata.

Specificare il percorso del nostro file di certificato autofirmato

#   Server Certificate:
# Point SSLCertificateFile at a PEM encoded certificate.  If
# the certificate is encrypted, then you will be prompted for a
# pass phrase.  Note that a kill -HUP will prompt again.  A new
# certificate can be generated using the genkey(1) command.
~~~~> SSLCertificateFile /etc/ssl/certs/self-sign-apache.crt
specify path to our private key file
#   Server Private Key:
#   If the key is not combined with the certificate, use this
#   directive to point at the key file.  Keep in mind that if
#   you've both a RSA and a DSA private key you can configure
#   both in parallel (to also allow the use of DSA ciphers, etc.)
~~~~> SSLCertificateKeyFile /etc/ssl/private/self-gen-apache.key

Infine, dobbiamo consentire le connessioni in entrata a https sulla porta 443.

In questo capitolo, impareremo un po 'il background di come è nato Apache HTTP Server e quindi installeremo la versione stabile più recente su CentOS Linux 7.

Breve storia su Apache WebServer

Apache è un server web che esiste da molto tempo. In effetti, quasi quanto l'esistenza di http stesso!

Apache è iniziato come un progetto piuttosto piccolo presso il National Center for Supercomputing Applications noto anche come NCSA. A metà degli anni '90 "httpd", come veniva chiamato, era di gran lunga la piattaforma di server web più popolare su Internet, con circa il 90% o più della quota di mercato.

A quel tempo, era un progetto semplice. Il personale IT qualificato noto come webmaster era responsabile di: mantenere le piattaforme di server web e il software del server web, nonché lo sviluppo di siti sia front-end che back-end. Al centro di httpd c'era la sua capacità di utilizzare moduli personalizzati noti come plugin o estensioni. Un webmaster era anche abbastanza abile da scrivere patch per il software server principale.

Verso la fine della metà degli anni '90, lo sviluppatore senior e project manager di httpd lasciò l'NCSA per fare altre cose. Ciò ha lasciato il demone web più popolare in uno stato di stagnazione.

Poiché l'uso di httpd era così diffuso, un gruppo di webmaster esperti di httpd ha chiesto un summit per domandare il futuro di httpd. Si è deciso di coordinare e applicare le migliori estensioni e patch in una versione stabile corrente. Quindi, l'attuale nonno dei server http è nato e battezzato Apache HTTP Server.

Little Known Historical Fact- Apache non prende il nome da una tribù di guerrieri nativi americani. È stato infatti coniato e chiamato con una svolta: essendo realizzato da molte correzioni (o patch) da molti talentuosi informatici: unpatchy o Apache.

Installa la versione stabile corrente su CentOS Linux 7

Step 1 - Installa httpd tramite yum.

yum -y install httpd

A questo punto Apache HTTP Server verrà installato tramite yum.

Step 2 - Modifica il file httpd.conf specifico per le tue esigenze httpd.

Con un'installazione predefinita di Apache, il file di configurazione per Apache è denominato httpd.conf e si trova in / etc / httpd / . Quindi, apriamolo in vim .

Le prime righe di httpd.conf sono state aperte in vim -

# 
# This is the main Apache HTTP server configuration file.  It contains the 
# configuration directives that give the server its instructions.
# See <URL:http://httpd.apache.org/docs/2.4/> for detailed information. 
# In particular, see  
# <URL:http://httpd.apache.org/docs/2.4/mod/directives.html> 
# for a discussion of each configuration directive.

Apporteremo le seguenti modifiche per consentire alla nostra installazione di CentOS di servire le richieste http dalla porta http 80.

Host in ascolto e porta

# Listen: Allows you to bind Apache to specific IP addresses and/or
# ports, instead of the default. See also the <VirtualHost>
# directive.
#
# Change this to Listen on specific IP addresses as shown below to
# prevent Apache from glomming onto all bound IP addresses.
#
#Listen 12.34.56.78:80
Listen 80

Da qui, cambiamo Apache per ascoltare su una determinata porta o indirizzo IP. Ad esempio, se vogliamo eseguire servizi httpd su una porta alternativa come 8080. Oppure se abbiamo il nostro server web configurato con più interfacce con indirizzi IP separati.

Ascolta

Impedisce ad Apache di collegarsi a ogni demone in ascolto su ogni indirizzo IP. Ciò è utile per smettere di specificare solo il traffico IPv6 o IPv4. O addirittura vincolanti a tutte le interfacce di rete su un host multi-homed.

#
# Listen: Allows you to bind Apache to specific IP addresses and/or
# ports, instead of the default. See also the <VirtualHost>
# directive.
#
# Change this to Listen on specific IP addresses as shown below to
# prevent Apache from glomming onto all bound IP addresses.
#
Listen 10.0.0.25:80
#Listen 80

DocumentRoot

La "root del documento" è la directory predefinita in cui Apache cercherà un file di indice da servire per le richieste dopo aver visitato il tuo server: http://www.yoursite.com/ recupererà e servirà il file di indice dalla radice del documento.

#
# DocumentRoot: The directory out of which you will serve your
# documents. By default, all requests are taken from this directory, but
# symbolic links and aliases may be used to point to other locations.
#
DocumentRoot "/var/www/html"

Step 3 - Avvia e abilita il servizio httpd.

[root@centos rdc]# systemctl start httpd && systemctl reload httpd 
[root@centos rdc]#

Step 4 - Configurare il firewall per consentire l'accesso alle richieste della porta 80.

[root@centos]# firewall-cmd --add-service=http --permanent

Come accennato brevemente durante la configurazione di CentOS per l'uso con Maria DB, non è presente alcun pacchetto MySQL nativo nel repository yum di CentOS 7 . Per tenere conto di ciò, avremo bisogno di aggiungere un repository ospitato da MySQL.

MariaDB vs MySQL su CentOS Linux

Una cosa da notare è che MySQL richiederà un diverso insieme di dipendenze di base da MariaDB. Anche l'utilizzo di MySQL romperà il concetto e la filosofia di CentOS: pacchetti di produzione progettati per la massima affidabilità.

Quindi, quando si decide se utilizzare Maria o MySQL, si dovrebbero valutare due opzioni: il mio attuale schema DB funzionerà con Maria? Quale vantaggio mi dà l'installazione di MySQL su Maria?

I componenti Maria sono trasparenti al 100% rispetto alla struttura MySQL, con una certa efficienza aggiuntiva con una licenza migliore. A meno che non si presenti una ragione convincente, si consiglia di configurare CentOS per utilizzare MariaDB.

I motivi principali per favorire Maria su CentOS sono:

La maggior parte delle persone utilizzerà MariaDB. In caso di problemi riceverai maggiore assistenza con Maria.
CentOS è progettato per funzionare con Maria. Quindi, Maria offrirà una migliore stabilità.
Maria è ufficialmente supportata per CentOS.

Scarica e aggiungi il repository MySQL

Vorremo scaricare e installare il repository MySQL da -

http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm

Step 1 - Scarica il repository.

Il repository viene convenientemente confezionato in un pacchetto rpm per una facile installazione. Può essere scaricato con wget -

[root@centos]# wget http://repo.mysql.com/mysql-community-release-el75.noarch.rpm
   --2017-02-26 03:18:36--  http://repo.mysql.com/mysql-community-release-el75.noarch.rpm
   Resolving repo.mysql.com (repo.mysql.com)... 104.86.98.130

Step 2 - Installa MySQL da YUM.

Ora possiamo usare il gestore di pacchetti yum per installare MySQL -

[root@centos]# yum -y install mysql-server

Step 3 - Avvia e abilita il servizio daemon MySQL.

[root@centos]# systemctl start mysql 
[root@centos]# systemctl enable  mysql

Step 4 - Assicurati che il nostro servizio MySQL sia attivo e funzionante.

[root@centos]# netstat -antup | grep 3306 
tcp6       0       0 :::3306       :::*       LISTEN       6572/mysqld
[root@centos]#

Nota: non consentiremo il passaggio di regole del firewall. È comune avere MySQL configurato per l'usoUnix Domain Sockets. Questo assicura che solo il server web dello stack LAMP, localmente, possa accedere al database MySQL, eliminando una dimensione completa nel vettore di attacco al software del database.

Per inviare un'e-mail dal nostro server CentOS 7, avremo bisogno della configurazione per configurare un moderno Mail Transfer Agent (MTA). Mail Transfer Agent è il daemon responsabile dell'invio della posta in uscita per gli utenti di sistema o i domini Internet aziendali tramite SMTP.

Vale la pena notare che questo tutorial insegna solo il processo di configurazione del demone per l'uso locale. Non entriamo nei dettagli sulla configurazione avanzata per l'impostazione di un MTA per le operazioni aziendali. Questa è una combinazione di molte abilità, tra cui ma non solo: DNS, ottenere un indirizzo IP instradabile statico che non è nella lista nera e configurare impostazioni avanzate di sicurezza e servizio. In breve, questo tutorial ha lo scopo di familiarizzare con la configurazione di base. Non utilizzare questo tutorial per la configurazione MTA di un host con connessione a Internet.

Con la sua attenzione combinata sia alla sicurezza che alla facilità di amministrazione, abbiamo scelto Postfixcome MTA per questo tutorial. L'MTA predefinito installato nelle versioni precedenti di CentOS è Sendmail .Sendmailè un ottimo MTA. Tuttavia, dell'umile parere dell'autore, Postfix ha un punto debole quando affronta le seguenti note per un MTA. Con la versione più recente di CentOS, Postfix ha sostituito Sendmail come MTA predefinito.

Postfix è un MTA ampiamente utilizzato e ben documentato. Viene mantenuto e sviluppato attivamente. Richiede una configurazione minima in mente (questa è solo posta elettronica) ed è efficiente con le risorse di sistema (di nuovo, questa è solo posta elettronica).

Step 1 - Installa Postfix da YUM Package Manager.

[root@centos]# yum -y install postfix

Step 2 - Configura il file di configurazione di Postfix.

Il file di configurazione di Postfix si trova in: /etc/postfix/main.cf

In una semplice configurazione Postfix, è necessario configurare quanto segue per un host specifico: nome host, dominio, origine, inet_interfaces e destinazione.

Configure the hostname- Il nome host è un nome di dominio completo dell'host Postfix. Nel capitolo OpenLDAP, abbiamo chiamato la casella CentOS: centos nel dominio vmnet.local . Continuiamo con quello per questo capitolo.

# The myhostname parameter specifies the internet hostname of this
# mail system. The default is to use the fully-qualified domain name
# from gethostname(). $myhostname is used as a default value for many
# other configuration parameters.
#
myhostname = centos.vmnet.local

Configure the domain- Come affermato sopra, il dominio che useremo in questo tutorial è vmnet.local

# The mydomain parameter specifies the local internet domain name.
# The default is to use $myhostname minus the first component. # $mydomain is used as a default value for many other configuration
# parameters.
#
mydomain = vmnet.local

Configure the origin - Per la configurazione di un singolo server e dominio, è sufficiente rimuovere il commento dalle sezioni seguenti e lasciare le variabili Postfix predefinite.

# SENDING MAIL
#
# The myorigin parameter specifies the domain that locally-posted
# mail appears to come from. The default is to append $myhostname, # which is fine for small sites. If you run a domain with multiple # machines, you should (1) change this to $mydomain and (2) set up
# a domain-wide alias database that aliases each user to
# [email protected].
#
# For the sake of consistency between sender and recipient addresses,
# myorigin also specifies the default domain name that is appended
# to recipient addresses that have no @domain part. 
#
myorigin = $myhostname myorigin = $mydomain

Configure the network interfaces- Lasceremo Postfix in ascolto sulla nostra singola interfaccia di rete e su tutti i protocolli e gli indirizzi IP associati a tale interfaccia. Questo viene fatto semplicemente lasciando le impostazioni predefinite abilitate per Postfix.

# The inet_interfaces parameter specifies the network interface
# addresses that this mail system receives mail on.  By default,
# the software claims all active interfaces on the machine. The
# parameter also controls delivery of mail to user@[ip.address].
#
# See also the proxy_interfaces parameter, for network addresses that
# are forwarded to us via a proxy or network address translator.
#
# Note: you need to stop/start Postfix when this parameter changes. 
#
#inet_interfaces = all
#inet_interfaces = $myhostname #inet_interfaces = $myhostname, localhost
#inet_interfaces = localhost
# Enable IPv4, and IPv6 if supported
inet_protocols = all

Step 3 - Configurare il supporto SASL per Postfix.

Senza il supporto dell'autenticazione SASL, Postfix consentirà solo l'invio di e-mail da utenti locali. Oppure darà un errore di inoltro negato quando gli utenti inviano messaggi di posta elettronica dal dominio locale.

Note - SASL o Simple Application Security Layer Frameworkè un framework progettato per l'autenticazione che supporta diverse tecniche tra i diversi protocolli di Application Layer. Invece di lasciare i meccanismi di autenticazione al protocollo del livello dell'applicazione, gli sviluppatori SASL (e i consumatori) sfruttano i protocolli di autenticazione correnti per protocolli di livello superiore che potrebbero non avere la comodità o un'autenticazione più sicura (quando si parla di accesso a servizi protetti) incorporata.

Installa il pacchetto "cyrus-sasl *

[root@centos]# yum -y install  cyrus-sasl 
Loaded plugins: fastestmirror, langpacks 
Loading mirror speeds from cached hostfile 
 * base: repos.forethought.net 
 * extras: repos.dfw.quadranet.com 
 * updates: mirrors.tummy.com 
Package cyrus-sasl-2.1.26-20.el7_2.x86_64 already installed and latest version
Nothing to do

Configurare /etc/postfix/main.cf per SASL Auth

smtpd_sasl_auth_enable = yes
smtpd_recipient_restrictions =
permit_mynetworks,permit_sasl_authenticated,reject_unauth_destination
smtpd_sasl_security_options = noanonymous
smtpd_sasl_type = dovecot
smtpd_sasl_path = private/auth

Le mie opzioni SASL in main.conf

##Configure SASL Options Entries:
smtpd_sasl_auth_enable = yes
smptd_recipient_restrictions =
permit_mynetworks,permit_sasl_authenticated,reject_unauth_destination
smtp_sasl_type = dovecot
smtp_sasl_path = private/auth/etc

Step 4 - Configurare FirewallD per consentire i servizi SMTP in entrata.

[root@centos]# firewall-cmd --permanent --add-service=smtp 
success

[root@centos]# firewall-cmd --reload 
success

[root@centos]#

Ora controlliamo per assicurarci che il nostro host CentOS consenta e risponda alle richieste sulla porta 25 (SMTP).

Nmap scan report for 172.16.223.132 
Host is up (0.00035s latency). 
Not shown: 993 filtered ports 
PORT    STATE  SERVICE 
   20/tcp  closed ftp-data 
   21/tcp  open   ftp 
   22/tcp  open   ssh 
   25/tcp  open   smtp 
   80/tcp  open   http 
   389/tcp open   ldap 
   443/tcp open   https 
MAC Address: 00:0C:29:BE:DF:5F (VMware)

Come puoi vedere, SMTP è in ascolto e il demone risponde alle richieste dalla nostra LAN interna.

Installa Dovecot IMAP e POP3 Server

Dovecot è un server IMAP e POP3 sicuro progettato per gestire le esigenze di posta in arrivo di un'organizzazione più piccola o più grande. A causa del suo utilizzo prolifico con CentOS, utilizzeremo Dovecot come esempio di installazione e configurazione di un server di posta in arrivo per CentOS e MTA SASL Provider.

Come notato in precedenza, non configureremo i record MX per DNS né creeremo regole sicure che consentano ai nostri servizi di gestire la posta per un dominio. Pertanto, la semplice configurazione di questi servizi su un host con accesso a Internet può lasciare spazio a falle di sicurezza senza record SPF.

Step 1 - Installa Dovecot.

[root@centos]# yum -y install dovecot

Step 2 - Configura dovecot.

Il file di configurazione principale per dovecot si trova in: /etc/dovecot.conf . Effettueremo prima il backup del file di configurazione principale. È buona norma eseguire sempre il backup dei file di configurazione prima di apportare modifiche. In questo modo le interruzioni di riga dell'ID (ad esempio) vengono distrutte da un editor di testo e gli anni di modifiche vengono persi. Il ripristino è facile come copiare il backup corrente in produzione.

Abilita i protocolli e il servizio daemon per dovecot

# Protocols we want to be serving. 
protocols = imap imaps pop3 pop3s

Ora, dobbiamo abilitare il demone dovecot ad ascoltare all'avvio -

[root@localhost]# systemctl start  dovecot 
[root@localhost]# systemctl enable dovecot

Assicuriamoci che Dovecot stia ascoltando localmente sulle porte specificate per: imap, pop3, imap secured e pop3 secured.

[root@localhost]# netstat -antup | grep dovecot 
 tcp        0        0 0.0.0.0:110        0.0.0.0:*        LISTEN        4368/dovecot
 tcp        0        0 0.0.0.0:143        0.0.0.0:*        LISTEN        4368/dovecot
 tcp        0        0 0.0.0.0:993        0.0.0.0:*        LISTEN        4368/dovecot
 tcp        0        0 0.0.0.0:995        0.0.0.0:*        LISTEN        4368/dovecot
 tcp6       0        0 :::110                :::*          LISTEN        4368/dovecot
 tcp6       0        0 :::143                :::*          LISTEN        4368/dovecot
 tcp6       0        0 :::993                :::*          LISTEN        4368/dovecot
 tcp6       0        0 :::995                :::*          LISTEN        4368/dovecot

[root@localhost]#

Come visto, dovecot è in ascolto sulle porte specificate per IPv4 e IPv4.

POP3	110
POP3	995
IMAP	143
IMAP	993

Ora, dobbiamo creare alcune regole del firewall.

[root@localhost]# firewall-cmd --permanent --add-port=110/tcp 
success
 
[root@localhost]# firewall-cmd --permanent --add-port=143/tcp 
success
 
[root@localhost]# firewall-cmd --permanent --add-port=995/tcp 
success
 
[root@localhost]# firewall-cmd --permanent --add-port=993/tcp 
success
 
[root@localhost]# firewall-cmd --reload 
success
 
[root@localhost]#

La nostra posta elettronica in entrata sever sta accettando le richieste di POP3 , POP3s , IMAP , e IMAPs a host sulla LAN.

Port Scanning host: 192.168.1.143

   Open TCP Port:   21          ftp 
   Open TCP Port:   22          ssh 
   Open TCP Port:   25          smtp 
   Open TCP Port:   80          http 
   Open TCP Port:   110         pop3 
   Open TCP Port:   143         imap 
   Open TCP Port:   443         https 
   Open TCP Port:   993         imaps 
   Open TCP Port:   995         pop3s

Prima di approfondire l'installazione di FTP su CentOS, dobbiamo imparare un po 'sul suo utilizzo e sulla sua sicurezza. FTPè un protocollo davvero efficiente e ben rifinito per il trasferimento di file tra i sistemi informatici. FTP è stato utilizzato e perfezionato da alcuni decenni. Per trasferire file in modo efficiente su una rete con latenza o per pura velocità, FTP è un'ottima scelta. Più che SAMBA o SMB.

Tuttavia, FTP possiede alcuni problemi di sicurezza. In realtà, alcuni seri problemi di sicurezza. FTP utilizza un metodo di autenticazione di testo semplice davvero debole. È per questo motivo che le sessioni autenticate dovrebbero fare affidamento su sFTP o FTPS, dove TLS viene utilizzato per la crittografia end-to-end delle sessioni di accesso e trasferimento.

Con le avvertenze di cui sopra, il semplice vecchio FTP ha ancora il suo uso nell'ambiente aziendale oggi. L'utilizzo principale è, archivi di file FTP anonimi. Questa è una situazione in cui non è garantita l'autenticazione per scaricare o caricare file. Alcuni esempi di utilizzo di FTP anonimo sono:

Le grandi società di software utilizzano ancora archivi ftp anonimi che consentono agli utenti di Internet di scaricare shareware e patch.
Consentire agli utenti di Internet di caricare e scaricare documenti pubblici.
Alcune applicazioni invieranno automaticamente registri crittografati e archiviati o file di configurazione a un repository tramite FTP.

Quindi, come amministratore di CentOS, essere in grado di installare e configurare FTP è ancora un'abilità progettata.

Useremo un demone FTP chiamato vsFTPo Daemon FTP molto sicuro. vsFTP è stato utilizzato nello sviluppo per un po '. Ha la reputazione di essere sicuro, facile da installare e configurare ed è affidabile.

Step 1 - Installa vsFTPd con il Gestore pacchetti YUM.

[root@centos]# yum -y install vsftpd.x86_64

Step 2 - Configura vsFTP per l'avvio all'avvio con systemctl.

[root@centos]# systemctl start vsftpd 
[root@centos]# systemctl enable vsftpd 
Created symlink from /etc/systemd/system/multi-
user.target.wants/vsftpd.service to /usr/lib/systemd/system/vsftpd.service.

Step 3 - Configurare FirewallD per consentire il controllo FTP e trasferire le sessioni.

[root@centos]# firewall-cmd --add-service=ftp --permanent 
success 
[root@centos]#

Assicurati che il nostro demone FTP sia in esecuzione.

[root@centos]# netstat -antup | grep vsftp 
tcp6       0       0 :::21       :::*       LISTEN       13906/vsftpd         
[root@centos]#

Step 4 - Configurare vsFTPD per l'accesso anonimo.

Crea una directory FTP principale

[root@centos]# mkdir /ftp

Cambia proprietario e gruppo di root FTP in ftp

[root@centos]# chown ftp:ftp /ftp
Set minimal permissions for FTP root:

[root@centos]# chmod -R 666 /ftp/

[root@centos]# ls -ld /ftp/
drw-rw-rw-. 2 ftp ftp 6 Feb 27 02:01 /ftp/

[root@centos]#

In questo caso, abbiamo fornito agli utenti l'accesso in lettura / scrittura all'intero albero FTP di root.

Configura /etc/vsftpd/vsftpd.conf "

[root@centos]# vim /etc/vsftpd/vsftpd.conf
# Example config file /etc/vsftpd/vsftpd.conf
#
# The default compiled in settings are fairly paranoid. This sample file
# loosens things up a bit, to make the ftp daemon more usable.
# Please see vsftpd.conf.5 for all compiled in defaults.
#
# READ THIS: This example file is NOT an exhaustive list of vsftpd options.
# Please read the vsftpd.conf.5 manual page to get a full idea of vsftpd's
# capabilities.

Vorremo modificare le seguenti direttive nel file vsftp.conf .

Abilita il caricamento anonimo rimuovendo il commento anon_mkdir_write_enable = YES
chown file caricati di proprietà dell'utente ftp di sistema

chown_uploads = SÌ

chown_username = ftp
Cambia l'utente di sistema utilizzato da vsftp con l'utente ftp: nopriv_user = ftp
Imposta il banner personalizzato che l'utente deve leggere prima di accedere.

ftpd_banner = Benvenuto nel nostro repository FTP anonimo. Tutte le connessioni vengono monitorate e registrate.
Impostiamo solo le connessioni IPv4 -

ascolta = YES

listen_ipv6 = NO

Ora, dobbiamo riavviare o HUP il servizio vsftp per applicare le nostre modifiche.

[root@centos]# systemctl restart vsftpd

Collegiamoci al nostro host FTP e assicuriamoci che il nostro demone FTP stia rispondendo.

[root@centos rdc]# ftp 10.0.4.34 
Connected to localhost (10.0.4.34). 
220 Welcome to our Anonymous FTP Repo. All connections are monitored and logged. 
Name (localhost:root): anonymous 
331 Please specify the password. 
Password: 
'230 Login successful. 
Remote system type is UNIX. 
Using binary mode to transfer files. 
ftp>

Quando parliamo di gestione remota in CentOS come amministratore, esploreremo due metodi:

Gestione della console
Gestione GUI

Gestione della console remota

Gestione della console remota significa eseguire attività di amministrazione dalla riga di comando tramite un servizio come ssh. Per utilizzare CentOS Linux in modo efficace, come amministratore, dovrai essere esperto con la riga di comando. Il cuore di Linux è stato progettato per essere utilizzato dalla console. Ancora oggi, alcuni amministratori di sistema preferiscono la potenza del comando e risparmiano sull'hardware eseguendo box Linux essenziali senza terminale fisico e senza GUI installata.

Gestione GUI remota

La gestione della GUI remota viene solitamente eseguita in due modi: una X-Session remota o un protocollo a livello di applicazione GUI come VNC. Ognuno ha i suoi punti di forza e di svantaggio. Tuttavia, per la maggior parte, VNC è la scelta migliore per l'amministrazione. Consente il controllo grafico da altri sistemi operativi come Windows o OS X che non supportano nativamente il protocollo X Windows.

L'uso di X Session remote è nativo sia per i Window-Manager di X-Window che per i DesktopManager in esecuzione su X. Tuttavia, l'intera architettura di X Session viene utilizzata principalmente con Linux. Non tutti gli amministratori di sistema avranno a portata di mano un laptop Linux per stabilire una sessione X remota. Pertanto, è più comune utilizzare una versione adattata di VNC Server.

I maggiori svantaggi di VNC sono: VNC non supporta nativamente un ambiente multiutente come le sessioni X remote. Quindi, per l'accesso GUI agli utenti finali, le sessioni XS remote sarebbero la scelta migliore. Tuttavia, ci occupiamo principalmente di amministrare un server CentOS da remoto.

Discuteremo la configurazione di VNC per più amministratori rispetto a poche centinaia di utenti finali con sessioni X remote.

Gettare le basi per la sicurezza con SSH per l'accesso alla console remota

ssh o Secure Shellè ora lo standard per l'amministrazione remota di qualsiasi server Linux. SSH a differenza di telnet utilizza TLS per l'autenticità e la crittografia end-to-end delle comunicazioni. Quando configurato correttamente, un amministratore può essere abbastanza sicuro che sia la password che il server siano attendibili in remoto.

Prima di configurare SSH, parliamo un po 'della sicurezza di base e dell'accesso meno comune. Quando SSH è in esecuzione sulla sua porta predefinita 22; prima o poi, si verificheranno attacchi di dizionario a forza bruta contro nomi utente e password comuni. Questo arriva solo con il territorio. Indipendentemente dal numero di host aggiunti ai file di negazione, arriveranno quotidianamente da indirizzi IP diversi.

Con alcune regole comuni, puoi semplicemente adottare alcuni passaggi proattivi e lasciare che i cattivi perdano il loro tempo. Di seguito sono riportate alcune regole di sicurezza da seguire utilizzando SSH per l'amministrazione remota su un server di produzione:

Non utilizzare mai un nome utente o una password comuni. I nomi utente sul sistema non dovrebbero essere quelli predefiniti del sistema o associati all'indirizzo e-mail dell'azienda come:[email protected]
L'accesso root o l'accesso amministrativo non dovrebbe essere consentito tramite SSH. Usa un nome utente univoco e su per eseguire il root o un account di amministrazione una volta autenticato tramite SSH.
La politica delle password è un must: password utente SSH complesse come: "Questo & IS & a & GUD & P @ ssW0rd & 24 & me". Modificare le password ogni pochi mesi per eliminare la suscettibilità agli attacchi di forza bruta incrementali.
Disattiva gli account abbandonati o inutilizzati per lunghi periodi. Se un responsabile delle assunzioni ha un messaggio vocale che afferma che non farà interviste per un mese; ad esempio, questo può portare a persone esperte di tecnologia con molto tempo a disposizione.
Guarda i tuoi registri ogni giorno. In qualità di amministratore di sistema, dedica almeno 30-40 minuti ogni mattina alla revisione dei registri di sistema e di sicurezza. Se richiesto, fai sapere a tutti che non hai tempo per non essere proattivo. Questa pratica aiuterà a isolare i segnali di allarme prima che un problema si presenti agli utenti finali e ai profitti dell'azienda.

Note On Linux Security- Chiunque sia interessato all'amministrazione Linux dovrebbe perseguire attivamente le notizie e le tecnologie attuali sulla sicurezza informatica. Anche se per lo più sentiamo parlare di altri sistemi operativi compromessi, una macchina Linux insicura è un tesoro ricercato per i criminali informatici. Con la potenza di Linux su una connessione Internet ad alta velocità, un criminale informatico esperto può utilizzare Linux per sfruttare gli attacchi su altri sistemi operativi.

Installa e configura SSH per l'accesso remoto

Step 1 - Installa il server SSH e tutti i pacchetti dipendenti.

[root@localhost]# yum -y install openssh-server 
'Loaded plugins: fastestmirror, langpacks 
Loading mirror speeds from cached hostfile 
* base: repos.centos.net 
* extras: repos.dfw.centos.com 
* updates: centos.centos.com 
Resolving Dependencies 
   --> Running transaction check 
   ---> Package openssh-server.x86_64 0:6.6.1p1-33.el7_3 will be installed 
   --> Finished Dependency Resolution 
Dependencies Resolved

Step 2 - Fai un uso regolare sicuro da aggiungere per l'accesso alla shell.

[root@localhost ~]# useradd choozer 
[root@localhost ~]# usermod -c "Remote Access" -d /home/choozer -g users -G 
wheel -a choozer

Note- Abbiamo aggiunto il nuovo utente al gruppo wheel abilitando la possibilità di eseguire su in root una volta che l'accesso SSH è stato autenticato. Abbiamo anche utilizzato un nome utente che non può essere trovato negli elenchi di parole comuni. In questo modo, il nostro account non verrà bloccato quando SSH viene attaccato.

Il file contenente le impostazioni di configurazione per il server sshd è / etc / ssh / sshd_config .

Le parti che vogliamo modificare inizialmente sono:

LoginGraceTime 60m
PermitRootLogin no

Step 3- Ricarica il demone SSH sshd .

[root@localhost]# systemctl reload sshd

È consigliabile impostare il periodo di tolleranza per il logout a 60 minuti. Alcune attività di amministrazione complesse possono superare il valore predefinito di 2 minuti. Non c'è davvero niente di più frustrante che avere il timeout della sessione SSH durante la configurazione o la ricerca delle modifiche.

Step 4 - Proviamo ad accedere utilizzando le credenziali di root.

bash-3.2# ssh centos.vmnet.local 
[email protected]'s password:   
Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password).

Step 5- Non possiamo più accedere da remoto tramite ssh con le credenziali di root . Quindi accediamo al nostro account utente non privilegiato e su nell'account root .

bash-3.2# ssh [email protected]
[email protected]'s password:
[choozer@localhost ~]$ su root
Password:

[root@localhost choozer]#

Step 6- Infine, assicuriamoci che il servizio SSHD venga caricato all'avvio e firewalld consenta connessioni SSH esterne.

[root@localhost]# systemctl enable sshd

[root@localhost]# firewall-cmd --permanent --add-service=ssh 
success

[root@localhost]# firewall-cmd --reload 
success
 
[root@localhost]#

SSH è ora configurato e pronto per l'amministrazione remota. A seconda del confine aziendale, potrebbe essere necessario configurare il dispositivo per il filtraggio dei pacchetti per consentire l'amministrazione remota SSH al di fuori della LAN aziendale.

Configurare VNC per l'amministrazione CentOS remota

Ci sono alcuni modi per abilitare l'amministrazione CentOS remota tramite VNC su CentOS 6-7. Il modo più semplice, ma più limitante, è semplicemente utilizzare un pacchetto chiamato vino .Vinoè un'applicazione di connessione desktop di rete virtuale per Linux progettata attorno alla piattaforma desktop Gnome. Quindi, si presume che l'installazione sia stata completata con Gnome Desktop. Se Gnome Desktop non è stato installato, fallo prima di continuare. Vino verrà installato con un'installazione GUI di Gnome per impostazione predefinita.

Per configurare la condivisione dello schermo con Vino sotto Gnome, vogliamo andare nelle Preferenze di Sistema di CentOS per la condivisione dello schermo.

Applications->System Tools->Settings->Sharing

Note per la configurazione della condivisione desktop VNC -

Disable New Connections must ask for access- Questa opzione richiederà l'accesso fisico per confermare ogni connessione. Questa opzione impedirà l'amministrazione remota a meno che qualcuno non si trovi sul desktop fisico.
Enable Require a password- Questo è separato dalla password utente. Controllerà l'accesso al desktop virtuale e richiederà comunque la password dell'utente per accedere a un desktop bloccato (questo è un bene per la sicurezza).
Forward UP&P Ports: If available leave disabled- L'inoltro delle porte UP&P invierà richieste Universal Plug and Play per un dispositivo di livello 3 per consentire automaticamente le connessioni VNC all'host. Non lo vogliamo.

Assicurati che vino sia in ascolto sulla porta VNC 5900.

[root@localhost]# netstat -antup | grep vino 
tcp        0        0 0.0.0.0:5900        0.0.0.0:*        LISTEN        4873/vino-server
tcp6       0        0 :::5900                :::*          LISTEN        4873/vino-server
   
[root@localhost]#

Configuriamo ora il nostro firewall per consentire le connessioni VNC in entrata.

[root@localhost]# firewall-cmd --permanent --add-port=5900/tcp 
success

[root@localhost]# firewall-cmd --reload 
success

[root@localhost rdc]#

Infine, come puoi vedere, siamo in grado di collegare la nostra CentOS Box e amministrarla con un client VNC su Windows o OS X.

È altrettanto importante obbedire alle stesse regole per VNC che abbiamo stabilito per SSH. Proprio come SSH, VNC viene continuamente scansionato su intervalli IP e testato per password deboli. Vale anche la pena notare che lasciare il login CentOS predefinito abilitato con un timeout della console aiuta con la sicurezza VNC remota. Poiché un utente malintenzionato avrà bisogno del VNC e della password utente, assicurati che la password di condivisione dello schermo sia diversa e altrettanto difficile da indovinare quanto la password dell'utente.

Dopo aver immesso la password di condivisione dello schermo VNC, è necessario immettere anche la password utente per accedere a un desktop bloccato.

Security Note- Per impostazione predefinita, VNC non è un protocollo crittografato. Quindi, la connessione VNC dovrebbe essere sottoposta a tunneling tramite SSH per la crittografia.

Configurazione del tunnel SSH tramite VNC

L'impostazione di un tunnel SSH fornirà un livello di crittografia SSH per eseguire il tunneling della connessione VNC. Un'altra grande caratteristica è che utilizza la compressione SSH per aggiungere un altro livello di compressione agli aggiornamenti dello schermo della GUI VNC. Più sicuro e più veloce è sempre una buona cosa quando si ha a che fare con l'amministrazione dei server CentOS!

Quindi dal tuo client che avvierà la connessione VNC, configuriamo un tunnel SSH remoto. In questa dimostrazione, stiamo usando OS X. Per prima cosa abbiamo bisogno di sudo -s per eseguire il root .

bash-3.2# sudo -s 
password:

Inserisci la password dell'utente e ora dovremmo avere la shell di root con un # prompt -

bash-3.2#

Ora creiamo il nostro tunnel SSH .

ssh -f [email protected] -L 2200:192.168.1.143:5900 -N

Rompiamo questo comando -

ssh - Esegue l'utilità ssh locale
-f - ssh dovrebbe essere eseguito in background dopo che l'attività è stata eseguita completamente
[email protected] - Utente ssh remoto sul server CentOS che ospita i servizi VNC
-L 2200:192.168.1.143:5900 - Crea il nostro tunnel [Porta locale]: [host remoto]: [porta remota del servizio VNC]
-N dice a ssh che non vogliamo eseguire un comando sul sistema remoto

bash-3.2# ssh -f [email protected] -L 2200:192.168.1.143:5900 -N
[email protected]'s password:

Dopo aver inserito con successo la password dell'utente ssh remoto, viene creato il nostro tunnel ssh . Ora per la parte interessante! Per connetterci puntiamo il nostro client VNC al localhost sulla porta del nostro tunnel, in questo caso la porta 2200. Di seguito è riportata la configurazione sul client VNC di Mac Laptop -

E infine, la nostra connessione desktop VNC remota!

La cosa interessante del tunneling SSH è che può essere utilizzato per quasi tutti i protocolli. I tunnel SSH vengono comunemente utilizzati per bypassare il filtraggio delle porte di ingresso e uscita da un ISP, nonché per ingannare IDS / IPS a livello di applicazione eludendo il monitoraggio di altri livelli di sessione.

Il tuo ISP può filtrare la porta 5900 per account non aziendali ma consentire SSH sulla porta 22 (o uno potrebbe eseguire SSH su qualsiasi porta se la porta 22 è filtrata).
IPS e IDS a livello di applicazione esaminano il payload. Ad esempio, un overflow del buffer comune o SQL Injection. La crittografia SSH end-to-end crittograferà i dati a livello di applicazione.

SSH Tunneling è un ottimo strumento nella casella degli strumenti di un amministratore Linux per fare le cose. Tuttavia, in qualità di amministratore, desideriamo esplorare il blocco della disponibilità di utenti con privilegi minori che hanno accesso al tunneling SSH.

Administration Security Note- Limitare il tunneling SSH è qualcosa che richiede una riflessione da parte di un amministratore. Valutare il motivo per cui gli utenti necessitano del tunneling SSH in primo luogo; di cosa hanno bisogno gli utenti di tunneling; insieme alla probabilità pratica del rischio e all'impatto nel caso peggiore.

Questo è un argomento avanzato che si estende al di fuori del regno di un primer di livello intermedio. La ricerca su questo argomento è consigliata a coloro che desiderano raggiungere i vertici dell'amministrazione CentOS Linux.

Usa il tunnel SSH per X-Windows remoto

Il design di X-Windows in Linux è davvero accurato rispetto a quello di Windows. Se vogliamo controllare un Linux box remoto da un altro Linux boxm possiamo sfruttare i meccanismi integrati in X.

X-Windows (spesso chiamato semplicemente "X"), fornisce il meccanismo per visualizzare le finestre dell'applicazione originate da una macchina Linux alla porzione di visualizzazione di X su un'altra macchina Linux. Quindi tramite SSH possiamo richiedere che un'applicazione X-Windows venga inoltrata al display di un'altra macchina Linux nel mondo!

Per eseguire un'applicazione X in remoto tramite un tunnel ssh, è sufficiente eseguire un singolo comando:

[root@localhost]# ssh -X [email protected]

The syntax is - ssh -X [utente] @ [host] e l'host deve eseguire ssh con un utente valido.

Di seguito è riportato uno screenshot di GIMP in esecuzione su una workstation Ubuntu attraverso un tunnel ssh XWindows remoto.

È abbastanza semplice eseguire applicazioni in remoto da un altro server o workstation Linux. È anche possibile avviare un'intera X-Session e disporre dell'intero ambiente desktop da remoto tramite alcuni metodi.

XDMCP
Pacchetti software senza testa come NX
Configurazione di schermi e desktop alternativi in X e desktop manager come Gnome o KDE

Questo metodo è più comunemente utilizzato per i server headless senza display fisico e supera davvero l'ambito di un primer di livello intermedio. Tuttavia, è bene conoscere le opzioni disponibili.

Esistono diversi strumenti di terze parti che possono aggiungere funzionalità avanzate per il monitoraggio del traffico CentOS. In questo tutorial, ci concentreremo su quelli che sono pacchettizzati nei principali repository di distribuzione CentOS e nel repository Fedora EPEL.

Ci saranno sempre situazioni in cui un amministratore (per un motivo o per l'altro) viene lasciato con solo strumenti nei repository CentOS principali. La maggior parte delle utilità discusse sono progettate per essere utilizzate da un amministratore con la shell di accesso fisico. Quando si monitora il traffico con una web-gui accessibile, l'utilizzo di utilità di terze parti come ntop-ng o Nagios è la scelta migliore (rispetto a ricreare tali strutture da zero).

Per ulteriori ricerche su entrambe le soluzioni web-gui configurabili, di seguito sono riportati alcuni collegamenti per iniziare la ricerca.

Monitoraggio del traffico per scenari LAN / WAN

Nagios

Nagios è in circolazione da molto tempo, quindi è sia provato che testato. A un certo punto era tutto gratuito e open source, ma da allora è diventato una soluzione Enterprise con modelli di licenza a pagamento per supportare le esigenze di sofisticazione Enterprise. Quindi, prima di pianificare qualsiasi implementazione con Nagios, assicurati che le versioni con licenza open source soddisfino le tue esigenze o pianifichi di spendere con un budget aziendale in mente.

La maggior parte dei software di monitoraggio del traffico Nagios open source può essere trovata su: https://www.nagios.org

Per un riepilogo della storia di Nagious, ecco la pagina ufficiale della storia di Nagios: https://www.nagios.org/about/history/

ntopng

Un altro ottimo strumento che consente il monitoraggio della larghezza di banda e del traffico tramite una web-gui è chiamato ntopng . ntopng è simile all'utility Unix ntop e può raccogliere dati per un'intera LAN o WAN. Fornire una web gui per l'amministrazione, la configurazione e la creazione di grafici lo rende facile da usare per tutti i reparti IT.

Come Nagious, ntopng ha sia versioni open source che aziendali a pagamento disponibili. Per ulteriori informazioni su ntopng , visitare il sito Web:http://www.ntop.org/

Installa Fedora EPEL Repository ─ Pacchetti extra per Enterprise Linux

Per accedere ad alcuni degli strumenti necessari per il monitoraggio del traffico, dovremo configurare il nostro sistema CentOS per utilizzare EPEL Repository.

Il repository EPEL non è ufficialmente mantenuto o supportato da CentOS. Tuttavia, è gestito da un gruppo di volontari Fedora Core per indirizzare i pacchetti comunemente usati dai professionisti di Enterprise Linux non inclusi in CentOS, Fedora Core o Red Hat Linux Enterprise.

Caution -

Ricorda, il repository EPEL non è ufficiale per CentOS e potrebbe interrompere la compatibilità e la funzionalità sui server di produzione con dipendenze comuni. Con questo in mente, si consiglia di testare sempre su un server non di produzione che esegue gli stessi servizi di produzione prima di eseguire la distribuzione su una scatola critica del sistema.

In realtà, il più grande vantaggio dell'utilizzo del repository EHEL rispetto a qualsiasi altro repository di terze parti con CentOS è che possiamo essere sicuri che i binari non siano contaminati. È considerata una best practice non utilizzare i repository da una fonte non attendibile.

Detto questo, il repository EPEL ufficiale è così comune con CentOS che può essere facilmente installato tramite YUM.

[root@CentOS rdc]# yum -y install epel-release
 Loaded plugins: fastestmirror, langpacks
 Loading mirror speeds from cached hostfile
 * base: repo1.dal.innoscale.net
 * extras: repo1.dal.innoscale.net
 * updates: mirror.hmc.edu
Resolving Dependencies
   --> Running transaction check
   ---> Package epel-release.noarch 0:7-9 will be installed
   --> Finished Dependency Resolution
Dependencies Resolved
--{ condensed output }--

Dopo aver installato EPEL Repository, vorremo aggiornarlo.

[root@CentOS rdc]# yum repolist 
Loaded plugins: fastestmirror, langpacks 
epel/x86_64/metalink
|  11 kB  00:00:00      
epel
| 4.3 kB  00:00:00      
(1/3): epel/x86_64/group_gz
| 170 kB  00:00:00      
(2/3): epel/x86_64/updateinfo
| 753 kB  00:00:01      
(3/3): epel/x86_64/primary_db
--{ condensed output }--

A questo punto, il nostro repository EPEL dovrebbe essere configurato e pronto per l'uso. Iniziamo installando nload per il monitoraggio della larghezza di banda dell'interfaccia.

Gli strumenti su cui ci concentreremo in questo tutorial sono:

nload
ntop
ifstst
iftop
vnstat
maiali netti
Wireshark
TCP Dump
Traceroute

Questi sono tutti standard per il monitoraggio del traffico nelle imprese Linux. L'utilizzo di ogni gamma da semplice ad avanzato, quindi discuteremo solo brevemente di strumenti come Wireshark e TCP Dump.

Installa e usa nload

Con i nostri repository EPEL installati e configurati in CentOS, ora dovremmo essere in grado di installare e utilizzare nload . Questa utility è progettata per tracciare la larghezza di banda per interfaccia in tempo reale.

Come la maggior parte delle altre installazioni di base, nload viene installato tramite il gestore di pacchetti YUM.

[root@CentOS rdc]# yum -y install nload
Resolving Dependencies
--> Running transaction check
---> Package nload.x86_64 0:0.7.4-4.el7 will be installed
--> Finished Dependency Resolution
Dependencies Resolved
=============================================================================== 
=============================================================================== 
 Package                             Arch
 Version                           Repository                          Size 
=============================================================================== 
=============================================================================== 
Installing: 
 nload                               x86_64
 0.7.4-4.el7                        epel                                70 k  
Transaction Summary
=============================================================================== 
=============================================================================== 
Install  1 Package
Total download size: 70 k
Installed size: 176 k
Downloading packages:
--{ condensed output }--

Ora abbiamo nload installato e usarlo è piuttosto semplice.

[root@CentOS rdc]# nload enp0s5

nload monitorerà l'interfaccia specificata. In questo caso, enp0s5 un'interfaccia Ethernet, in tempo reale dal terminale per i carichi del traffico di rete e l'utilizzo totale della larghezza di banda.

Come visto, nload traccia i dati in entrata e in uscita dall'interfaccia specificata, oltre a fornire una rappresentazione fisica del flusso di dati con segni di cancelletto "#".

Lo screenshot raffigurato mostra una semplice pagina web caricata con un po 'di traffico daemon in background.

Le opzioni della riga di comando comuni per nload sono:

Comando	Azione
-un	Periodo di tempo
-t	Intervallo di aggiornamento del tempo in millisecondi, il valore predefinito è 500
-u	Imposta la visualizzazione della misurazione del traffico h
-U	Imposta le unità di misura del traffico totale in entrata / uscita con le stesse opzioni di -u

La sintassi standard per nload è:

nload [options] <interface>

Se non viene specificata alcuna interfaccia, nload acquisirà automaticamente la prima interfaccia Ethernet. Proviamo a misurare i dati totali in ingresso / uscita in megabyte e le attuali velocità di trasferimento dati in megabit.

[root@CentOS rdc]# nload -U M -u m

I dati in entrata / uscita dall'interfaccia corrente sono misurati in megabit al secondo e ciascuna riga "Ttl", che rappresenta i dati totali in entrata / uscita, viene visualizzata in Megabyte.

nload è utile per un amministratore per vedere quanti dati sono passati attraverso un'interfaccia e quanti dati sono attualmente in entrata / uscita da un'interfaccia specificata.

Per vedere altre interfacce senza chiudere nload, usa semplicemente i tasti freccia sinistra / destra. Questo scorrerà attraverso tutte le interfacce disponibili sul sistema.

È possibile monitorare più interfacce contemporaneamente utilizzando lo switch -m -

[root@CentOS rdc]# nload -u K -U M -m lo -m enp0s5

monitoraggio del carico di due interfacce contemporaneamente (lo e enp0s5) -

systemd ha cambiato il modo in cui viene gestita la registrazione del sistema per CentOS Linux. Invece di ogni demone sul sistema che inserisce i log in posizioni individuali piuttosto che usare strumenti come tail o grep come metodo principale per ordinare e filtrare le voci di log,journald ha portato un unico punto di amministrazione per analizzare i log di sistema.

I componenti principali alla base della registrazione di systemd sono: journal, jounralctl e journald.conf

journald è il demone di registrazione principale ed è configurato modificando journald.conf mentre journalctl viene utilizzato per analizzare gli eventi registrati da journald .

Gli eventi registrati da journald includono: eventi del kernel, processi utente e servizi daemon.

Impostare il fuso orario di sistema corretto

Prima di utilizzare journalctl , dobbiamo assicurarci che l'ora del nostro sistema sia impostata sull'ora corretta. Per fare questo, vogliamo utilizzare timedatectl .

Controlliamo l'ora di sistema corrente.

[root@centos rdc]# timedatectl status 
Local time: Mon 2017-03-20 00:14:49 MDT 
Universal time: Mon 2017-03-20 06:14:49 UTC 
RTC time: Mon 2017-03-20 06:14:49 
Time zone: America/Denver (MDT, -0600) 
NTP enabled: yes 
NTP synchronized: yes 
RTC in local TZ: no 
DST active: yes 
Last DST change: DST began at 
              Sun 2017-03-12 01:59:59 MST 
              Sun 2017-03-12 03:00:00 MDT 
Next DST change: DST ends (the clock jumps one hour backwards) at 
              Sun 2017-11-05 01:59:59 MDT 
              Sun 2017-11-05 01:00:00 MST
              
[root@centos rdc]#

Attualmente, il sistema è corretto per il fuso orario locale. Se il tuo sistema non lo è, impostiamo il fuso orario corretto. Dopo aver modificato le impostazioni, CentOS calcolerà automaticamente lo scostamento del fuso orario dal fuso orario corrente, regolando immediatamente l'orologio di sistema.

Elenchiamo tutti i fusi orari con timedatectl -

[root@centos rdc]# timedatectl list-timezones 
Africa/Abidjan
Africa/Accra
Africa/Addis_Ababa
Africa/Algiers
Africa/Asmara
Africa/Bamako
Africa/Bangui
Africa/Banjul
Africa/Bissau

Questo è l'output conteso da timedatectl list-timezones . Per trovare un fuso orario locale specifico, è possibile utilizzare il comando grep:

[root@centos rdc]# timedatectl list-timezones | grep -i "america/New_York" 
America/New_York
[root@centos rdc]#

L'etichetta usata da CentOS è solitamente Paese / Regione con un trattino basso invece dello spazio (New_York rispetto a "New York").

Ora impostiamo il nostro fuso orario -

[root@centos rdc]# timedatectl set-timezone "America/New_York"

[root@centos rdc]# date 
Mon Mar 20 02:28:44 EDT 2017

[root@centos rdc]#

L'orologio di sistema dovrebbe regolare automaticamente l'ora.

Usa journalctl per analizzare i log

Opzioni comuni della riga di comando quando si utilizza journalctl -

Interruttore	Azione
-K	Elenca solo i messaggi del kernel
-u	Elenchi per unità specifica (httpd, sshd, ecc ...)
-b	Avvia l'offset dell'etichetta
-o	Registra il formato di output
-p	Filtri per tipo di registro (nome o numero)
-F	Fieldname o fieldnamevalue
--utc	Ora in offset UTC
--da	Filtra per periodo di tempo

Esamina i registri di avvio

Innanzitutto, esamineremo e configureremo i log di avvio in CentOS Linux. La prima cosa che noterai è che CentOS, per impostazione predefinita, non memorizza il registro di avvio che è persistente durante i riavvii.

Per controllare i log di avvio per ogni istanza di riavvio, possiamo emettere il seguente comando:

[root@centos rdc]# journalctl --list-boots 
-4 bca6380a31a2463aa60ba551698455b5 Sun 2017-03-19 22:01:57 MDT—Sun 2017-03-19 22:11:02 MDT
-3 3aaa9b84f9504fa1a68db5b49c0c7208 Sun 2017-03-19 22:11:09 MDT—Sun 2017-03-19 22:15:03 MDT
-2 f80b231272bf48ffb1d2ce9f758c5a5f Sun 2017-03-19 22:15:11 MDT—Sun 2017-03-19 22:54:06 MDT
-1 a071c1eed09d4582a870c13be5984ed6 Sun 2017-03-19 22:54:26 MDT—Mon 2017-03-20 00:48:29 MDT
 0 9b4e6cdb43b14a328b1fa6448bb72a56 Mon 2017-03-20 00:48:38 MDT—Mon 2017-03-20 01:07:36 MDT

[root@centos rdc]#

Dopo aver riavviato il sistema, possiamo vedere un'altra voce.

[root@centos rdc]# journalctl --list-boots 
-5 bca6380a31a2463aa60ba551698455b5 Sun 2017-03-19 22:01:57 MDT—Sun 2017-03-19 22:11:02 MDT
-4 3aaa9b84f9504fa1a68db5b49c0c7208 Sun 2017-03-19 22:11:09 MDT—Sun 2017-03-19 22:15:03 MDT
-3 f80b231272bf48ffb1d2ce9f758c5a5f Sun 2017-03-19 22:15:11 MDT—Sun 2017-03-19 22:54:06 MDT
-2 a071c1eed09d4582a870c13be5984ed6 Sun 2017-03-19 22:54:26 MDT—Mon 2017-03-20 00:48:29 MDT
-1 9b4e6cdb43b14a328b1fa6448bb72a56 Mon 2017-03-20 00:48:38 MDT—Mon 2017-03-20 01:09:57 MDT
 0 aa6aaf0f0f0d4fcf924e17849593d972 Mon 2017-03-20 01:10:07 MDT—Mon 2017-03-20 01:12:44 MDT
 
[root@centos rdc]#

Ora, esaminiamo l'ultima istanza di registrazione di avvio:

root@centos rdc]# journalctl -b -5 
-- Logs begin at Sun 2017-03-19 22:01:57 MDT, end at Mon 2017-03-20 01:20:27 MDT. --
Mar 19 22:01:57 localhost.localdomain systemd-journal[97]: Runtime journal is using 8.0M 
(max allowed 108.4M
Mar 19 22:01:57 localhost.localdomain kernel: Initializing cgroup subsys cpuset
Mar 19 22:01:57 localhost.localdomain kernel: Initializing cgroup subsys cpu
Mar 19 22:01:57 localhost.localdomain kernel: Initializing cgroup subsys cpuacct
Mar 19 22:01:57 localhost.localdomain kernel: Linux version 3.10.0514.6.2.el7.x86_64 
([email protected].
Mar 19 22:01:57 localhost.localdomain kernel: Command line: 
BOOT_IMAGE=/vmlinuz-3.10.0-514.6.2.el7.x86_64 ro
Mar 19 22:01:57 localhost.localdomain kernel: Disabled fast string operations
Mar 19 22:01:57 localhost.localdomain kernel: e820: BIOS-provided physical RAM map:

Sopra c'è l'output condensato del nostro ultimo avvio. Potremmo anche fare riferimento a un registro di avvio di ore, giorni, settimane, mesi e persino anni. Tuttavia, per impostazione predefinita CentOS non archivia i registri di avvio persistenti. Per abilitare l'archiviazione persistente dei log di avvio, è necessario apportare alcune modifiche alla configurazione:

Crea punti di archiviazione centrali per i registri di avvio
Assegna le autorizzazioni appropriate a una nuova cartella di registro
Configurare journald.conf per la registrazione persistente

Configurare la posizione di avvio per i registri di avvio persistenti

La posizione iniziale in cui journald vorrà memorizzare i log di avvio persistenti è / var / log / journal . Poiché questo non esiste di default, creiamolo -

[root@centos rdc]# mkdir /var/log/journal

Ora, diamo alla directory le autorizzazioni appropriate per l' accesso daemon journald -

systemd-tmpfiles --create --prefix /var/log/journal

Infine, diciamo a journald di memorizzare i log di avvio persistenti. In vim o nel tuo editor di testo preferito, apri /etc/systemd/jounrald.conf " .

# See journald.conf(5) for details.  
[Journal]=Storage=peristent

La linea di cui ci occupiamo è Storage = . Rimuovere prima il commento # , quindi passare aStorage = persistentcome illustrato sopra. Salva e riavvia il tuo sistema CentOS e assicurati che ci siano più voci durante l'esecuzione di journalctl list-boot .

Note- Un ID macchina in costante cambiamento come quello di un provider VPS può impedire a journald di memorizzare i log di avvio persistenti. Esistono molte soluzioni alternative per un tale scenario. È meglio esaminare attentamente le correzioni correnti pubblicate nei forum di amministrazione di CentOS, piuttosto che seguire i consigli affidabili di coloro che hanno trovato soluzioni alternative VPS plausibili.

Per esaminare un log di avvio specifico, dobbiamo semplicemente ottenere ogni offset usando journald --list-avvia l'offset con l' opzione -b . Quindi per controllare il secondo registro di avvio che useremmo -

journalctl -b -2

L'impostazione predefinita per -b senza l'offset del registro di avvio specificato sarà sempre il registro di avvio corrente dopo l'ultimo riavvio.

Analizza i registri per tipo di registro

Gli eventi di journald sono numerati e classificati in 7 tipi separati:

0 - emerg   :: System is unusable 
1 - alert   :: Action must be taken immediatly    
2 - crit    :: Action is advised to be taken immediatly 
3 - err     :: Error effecting functionality of application 
4 - warning :: Usually means a common issue that can affect security or usilbity 
5 - info    :: logged informtation for common operations 
6 - debug   :: usually disabled by default to troubleshoot functionality

Quindi, se vogliamo vedere tutti gli avvisi, il seguente comando può essere emesso tramite journalctl -

[root@centos rdc]# journalctl -p 4
-- Logs begin at Sun 2017-03-19 22:01:57 MDT, end at Wed 2017-03-22 22:33:42 MDT. --
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: RSDP 00000000000f6a10 00024
(v02 PTLTD )
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: XSDT 0000000095eea65b 0005C
(v01 INTEL  440BX    06040000 VMW  01
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: FACP 0000000095efee73 000F4
(v04 INTEL  440BX    06040000 PTL  00
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: DSDT 0000000095eec749 1272A
(v01 PTLTD  Custom   06040000 MSFT 03
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: FACS 0000000095efffc0 00040
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: BOOT 0000000095eec721 00028
(v01 PTLTD  $SBFTBL$ 06040000 LTP 00 Mar 19 22:01:57 localhost.localdomain kernel: ACPI: APIC 0000000095eeb8bd 00742 (v01 PTLTD ? APIC 06040000 LTP 00 Mar 19 22:01:57 localhost.localdomain kernel: ACPI: MCFG 0000000095eeb881 0003C (v01 PTLTD $PCITBL$ 06040000  LTP 00 
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: SRAT 0000000095eea757 008A8
(v02 VMWARE MEMPLUG  06040000 VMW  00 
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: HPET 0000000095eea71f 00038
(v01 VMWARE VMW HPET 06040000 VMW  00 
Mar 19 22:01:57 localhost.localdomain kernel: ACPI: WAET 0000000095eea6f7 00028
(v01 VMWARE VMW WAET 06040000 VMW  00 
Mar 19 22:01:57 localhost.localdomain kernel: Zone ranges: 
Mar 19 22:01:57 localhost.localdomain kernel:   DMA      [mem 0x000010000x00ffffff] 
Mar 19 22:01:57 localhost.localdomain kernel:   DMA32    [mem 0x010000000xffffffff] 
Mar 19 22:01:57 localhost.localdomain kernel:   Normal   empty 
Mar 19 22:01:57 localhost.localdomain kernel: Movable zone start for each node 
Mar 19 22:01:57 localhost.localdomain kernel: Early memory node ranges 
Mar 19 22:01:57 localhost.localdomain kernel:   node   0: [mem 0x000010000x0009dfff] 
Mar 19 22:01:57 localhost.localdomain kernel:   node   0: [mem 0x001000000x95edffff] 
Mar 19 22:01:57 localhost.localdomain kernel:   node   0: [mem 0x95f000000x95ffffff] 
Mar 19 22:01:57 localhost.localdomain kernel: Built 1 zonelists in Node order,
mobility grouping on.  Total pages: 60 
Mar 19 22:01:57 localhost.localdomain kernel: Policy zone: DMA32 
Mar 19 22:01:57 localhost.localdomain kernel: ENERGY_PERF_BIAS: Set to
'normal', was 'performance'

Quanto sopra mostra tutti gli avvisi per gli ultimi 4 giorni sul sistema.

Il nuovo modo di visualizzare ed esaminare i registri con systemd richiede poca pratica e ricerca per acquisire familiarità. Tuttavia, con diversi formati di output e un avviso particolare per rendere universali tutti i registri dei demoni pacchettizzati, vale la pena abbracciarlo. journald offre grande flessibilità ed efficienza rispetto ai tradizionali metodi di analisi dei log.

Prima di esplorare i metodi specifici di CentOS per la distribuzione di un piano di backup standard, discutiamo prima di considerazioni tipiche per una policy di backup di livello standard. La prima cosa a cui vogliamo abituarci è il file3-2-1 backup rule.

3-2-1 Strategia di backup

In tutto il settore, sentirai spesso il termine modello di backup 3-2-1. Questo è un ottimo approccio da seguire quando si implementa un piano di backup. 3-2-1 è definito come segue:3copie di dati; per esempio, potremmo avere la copia di lavoro; una copia inserita nel server CentOS progettato per la ridondanza utilizzando rsync; e i backup USB esterni ruotati vengono eseguiti dai dati sul server di backup.2diversi supporti di backup. In questo caso avremmo in realtà tre diversi supporti di backup: la copia di lavoro su un SSD di un laptop o una workstation, i dati del server CentOS su un array RADI6 ei backup offsite inseriti su unità USB.1copia dei dati fuori sede; stiamo ruotando le unità USB fuori sede ogni notte. Un altro approccio moderno potrebbe essere un provider di backup su cloud.

Ripristino del sistema

Un piano di ripristino bare metal è semplicemente un piano elaborato da un amministratore CentOS per mettere in linea i sistemi vitali con tutti i dati intatti. Presumendo il 100% di guasti ai sistemi e la perdita di tutto l'hardware del sistema precedente, un amministratore deve avere un piano per ottenere tempi di attività con dati utente intatti che costano tempi di inattività minimi. Il kernel monolitico utilizzato in Linux rende effettivamente i ripristini bare metal utilizzando immagini di sistema molto più semplici di Windows. Dove Windows utilizza un'architettura micro-kernel.

Un ripristino completo dei dati e un ripristino bare metal vengono generalmente eseguiti tramite una combinazione di metodi, tra cui immagini disco di produzione configurate di server operativi chiave, backup ridondanti dei dati utente conformi alla regola 3-2-1. Anche alcuni file sensibili che possono essere archiviati in una cassaforte sicura e ignifuga con accesso limitato al personale dell'azienda di fiducia.

Un ripristino bare metal multifase e un piano di ripristino dei dati utilizzando strumenti CentOS nativi può consistere in:

dd per creare e ripristinare le immagini del disco di produzione dei server configurati
rsync per eseguire backup incrementali di tutti i dati utente
tar & gzip per archiviare backup crittografati di file con password e note degli amministratori. Di solito, questo può essere inserito su un'unità USB, crittografato e bloccato in una cassaforte a cui accede un Senior Manager. Inoltre, questo garantisce che qualcun altro conoscerà le credenziali di sicurezza vitali se l'attuale amministratore vince la lotteria e scompare su un'isola soleggiata da qualche parte.

Se un sistema si arresta in modo anomalo a causa di un errore hardware o di un disastro, di seguito saranno riportate le diverse fasi delle operazioni di ripristino:

Crea un server funzionante con un'immagine bare metal configurata
Ripristina i dati sul server funzionante dai backup
Avere accesso fisico alle credenziali necessarie per eseguire le prime due operazioni

Usa rsync per i backup a livello di file

rsync è un'ottima utility per sincronizzare directory di file localmente o su un altro server. rsync è stato utilizzato per anni dagli amministratori di sistema, quindi è molto raffinato allo scopo di eseguire il backup dei dati. Secondo l'autore, una delle migliori caratteristiche della sincronizzazione è la sua capacità di essere scriptato dalla riga di comando.

In questo tutorial, discuteremo di rsync in vari modi:

Esplora e parla di alcune opzioni comuni
Crea backup locali
Crea backup remoti su SSH
Ripristina backup locali

rsyncprende il nome dal suo scopo: Remote Sync ed è potente e flessibile nell'uso.

Di seguito è riportato un backup remoto rsync di base su ssh -

MiNi:~ rdc$ rsync -aAvz --progress ./Desktop/ImportantStuff/ 
[email protected]:home/rdc/ Documents/RemoteStuff/
[email protected]'s password:
sending incremental file list
   6,148 100%    0.00kB/s    0:00:00 (xfr#1, to-chk=23/25)
2017-02-14 16_26_47-002 - Veeam_Architecture001.png
   33,144 100%   31.61MB/s    0:00:00 (xfr#2, to-chk=22/25)
A Guide to the WordPress REST API | Toptal.pdf
   892,406 100%   25.03MB/s    0:00:00 (xfr#3, to-chk=21/25)
Rick Cardon Technologies, LLC..webloc
   77 100%    2.21kB/s    0:00:00 (xfr#4, to-chk=20/25)
backbox-4.5.1-i386.iso
   43,188,224   1%    4.26MB/s    0:08:29
sent 2,318,683,608 bytes  received 446 bytes  7,302,941.90 bytes/sec
total size is 2,327,091,863  speedup is 1.00
MiNi:~ rdc$

La seguente sincronizzazione ha inviato quasi 2,3 GB di dati attraverso la nostra LAN. La bellezza di rsync è che funziona in modo incrementale a livello di blocco, file per file. Ciò significa che, se cambiamo solo due caratteri in un file di testo da 1 MB, solo uno o due blocchi verranno trasferiti attraverso la lan alla sincronizzazione successiva!

Inoltre, la funzione incrementale può essere disabilitata a favore di una maggiore larghezza di banda di rete utilizzata per un minore utilizzo della CPU. Ciò potrebbe rivelarsi consigliabile se si copiano costantemente diversi file di database da 10 MB ogni 10 minuti su una Backup-Lan dedicata da 1 GB. Il ragionamento è: questi cambieranno sempre e trasmetteranno in modo incrementale ogni 10 minuti e potrebbero gravare sul carico della CPU remota. Poiché il carico di trasferimento totale non supererà i 5 minuti, potremmo semplicemente sincronizzare i file del database nella loro interezza.

Di seguito sono riportate le opzioni più comuni con rsync :

rsync syntax:
rsync [options] [local path] [[remote host:remote path] or [target path

Interruttore	Azione
-un	Modalità archivio e presuppone -r, -p, -t, -g, -l
-d	Sincronizza solo l'albero delle directory, nessun file
-r	Ricorsivo in directory
-l	Copia i collegamenti simbolici come collegamenti simbolici
-p	Conserva le autorizzazioni
-g	Conserva il gruppo
-v	Output dettagliato
-z	Comprimi su collegamento di rete
-X	Conserva gli attributi estesi
-UN	Conserva gli ACL
-t	Conserva i timestamp
-W	Trasferisci l'intero file, non i blocchi incrementali
-u	Non sovrascrivere i file sulla destinazione
--progresso	Mostra l'avanzamento del trasferimento
--Elimina	Elimina i file più vecchi sulla destinazione
--max-size = XXX	Dimensione massima del file da sincronizzare

Quando usare rsync

La mia preferenza personale per rsync è quando eseguo il backup dei file da un host di origine a un host di destinazione. Ad esempio, tutte le home directory per il ripristino dei dati o anche fuori sede e nel cloud per il ripristino di emergenza.

Backup locale con rsync

Abbiamo già visto come trasferire file da un host all'altro. Lo stesso metodo può essere utilizzato per sincronizzare directory e file localmente.

Facciamo un backup incrementale manuale di / etc / nella directory del nostro utente root.

Innanzitutto, dobbiamo creare una directory fuori ~ / root per il backup sincronizzato -

[root@localhost rdc]# mkdir /root/etc_baks

Quindi, assicurati che ci sia abbastanza spazio libero su disco.

[root@localhost rdc]# du -h --summarize /etc/ 
49M    /etc/
 
[root@localhost rdc]# df -h 
Filesystem           Size     Used     Avail    Use%     Mounted on 
/dev/mapper/cl-root   43G      15G        28G    35%         /

Siamo bravi a sincronizzare la nostra intera directory / etc / -

rsync -aAvr /etc/ /root/etc_baks/

La nostra directory / etc / sincronizzata -

[root@localhost etc_baks]# ls -l ./
total 1436
drwxr-xr-x.   3 root root      101 Feb  1 19:40 abrt
-rw-r--r--.   1 root root       16 Feb  1 19:51 adjtime
-rw-r--r--.   1 root root     1518 Jun  7  2013 aliases
-rw-r--r--.   1 root root    12288 Feb 27 19:06 aliases.db
drwxr-xr-x.   2 root root       51 Feb  1 19:41 alsa
drwxr-xr-x.   2 root root     4096 Feb 27 17:11 alternatives
-rw-------.   1 root root      541 Mar 31  2016 anacrontab
-rw-r--r--.   1 root root       55 Nov  4 12:29 asound.conf
-rw-r--r--.   1 root root        1 Nov  5 14:16 at.deny
drwxr-xr-x.   2 root root       32 Feb  1 19:40 at-spi2
--{ condensed output }--

Ora facciamo un rsync incrementale -

[root@localhost etc_baks]# rsync -aAvr --progress  /etc/ /root/etc_baks/
sending incremental file list

test_incremental.txt 
   0 100%    0.00kB/s    0:00:00 (xfer#1, to-check=1145/1282)
   
sent 204620 bytes  received 2321 bytes  413882.00 bytes/sec
total size is 80245040  speedup is 387.77

[root@localhost etc_baks]#

È stato copiato solo il nostro file test_incremental.txt .

Backup differenziali remoti con rsync

Facciamo il nostro backup completo rsync iniziale su un server con un piano di backup distribuito. Questo esempio sta effettivamente eseguendo il backup di una cartella su una workstation Mac OS X su un server CentOS. Un altro grande aspetto di rsync è che può essere utilizzato su qualsiasi piattaforma su cui rsync è stato portato.

MiNi:~ rdc$ rsync -aAvz Desktop/ImportanStuff/
[email protected]:Documents/RemoteStuff
[email protected]'s password:
sending incremental file list
./
A Guide to the WordPress REST API | Toptal.pdf
Rick Cardon Tech LLC.webloc
VeeamDiagram.png
backbox-4.5.1-i386.iso
dhcp_admin_script_update.py
DDWRT/
DDWRT/.DS_Store
DDWRT/ddwrt-linksys-wrt1200acv2-webflash.bin
DDWRT/ddwrt_mod_notes.docx
DDWRT/factory-to-ddwrt.bin
open_ldap_config_notes/
open_ldap_config_notes/ldap_directory_a.png
open_ldap_config_notes/open_ldap_notes.txt
perl_scripts/
perl_scripts/mysnmp.pl
php_scripts/
php_scripts/chunked.php
php_scripts/gettingURL.php
sent 2,318,281,023 bytes  received 336 bytes  9,720,257.27 bytes/sec
total size is 2,326,636,892  speedup is 1.00
MiNi:~ rdc$

Ora è stato eseguito il backup di una cartella da una workstation su un server che esegue un volume RAID6 con un supporto di ripristino di emergenza ruotato archiviato fuori sede. L'uso di rsync ci ha fornito un backup standard 3-2-1 con un solo server con un costoso array di dischi ridondante e backup differenziali ruotati.

Ora facciamo un altro backup della stessa cartella usando rsync dopo che è stato aggiunto un singolo nuovo file chiamato test_file.txt .

MiNi:~ rdc$ rsync -aAvz Desktop/ImportanStuff/
[email protected]:Documents/RemoteStuff 
[email protected]'s password:  
sending incremental file list 
 ./ 
test_file.txt

sent 814 bytes  received 61 bytes  134.62 bytes/sec
total size is 2,326,636,910  speedup is 2,659,013.61
MiNi:~ rdc$

Come puoi vedere, solo il nuovo file è stato consegnato al server tramite rsync . Il confronto differenziale è stato effettuato file per file.

Alcune cose da notare sono: Questo copia solo il nuovo file: test_file.txt, poiché era l'unico file con modifiche. rsync usa ssh. Non abbiamo mai avuto bisogno di usare il nostro account di root su nessuna macchina.

Semplice, potente ed efficace, rsync è ottimo per il backup di intere cartelle e strutture di directory. Tuttavia, rsync da solo non automatizza il processo. È qui che dobbiamo scavare nella nostra cassetta degli attrezzi e trovare lo strumento migliore, piccolo e semplice per il lavoro.

Per automatizzare i backup rsync con cronjobs , è essenziale che gli utenti SSH siano configurati utilizzando le chiavi SSH per l'autenticazione. Questo combinato con cronjobs consente a rsync di essere eseguito automaticamente a intervalli di tempo.

Usa DD per immagini di ripristino bare metal blocco per blocco

DD è un'utilità Linux che esiste dagli albori del kernel Linux che incontra le utilità GNU.

dd in termini più semplici copia un'immagine di un'area del disco selezionata. Fornisce quindi la possibilità di copiare i blocchi selezionati di un disco fisico. Quindi, a meno che tu non abbia backup, una volta che dd scrive su un disco, tutti i blocchi vengono sostituiti. La perdita di dati precedenti supera le capacità di ripristino anche per il ripristino dei dati di livello professionale ad alto prezzo.

L'intero processo per creare un'immagine di sistema avviabile con dd è il seguente:

Avvia dal server CentOS con una distribuzione Linux avviabile
Trova la designazione del disco di avvio di cui eseguire l'immagine
Decidi la posizione in cui archiviare l'immagine di ripristino
Trova la dimensione del blocco utilizzata sul tuo disco
Avvia l'operazione dd image

In questo tutorial, per motivi di tempo e semplicità, creeremo un'immagine ISO del record di avvio principale da una macchina virtuale CentOS. Memorizzeremo quindi questa immagine fuori sede. Nel caso in cui il nostro MBR venga danneggiato e debba essere ripristinato, lo stesso processo può essere applicato a un intero disco o partizione di avvio. Tuttavia, il tempo e lo spazio su disco necessari sono davvero un po 'esagerati per questo tutorial.

Si consiglia agli amministratori di CentOS di acquisire familiarità con il ripristino di un disco / partizione completamente avviabile in un ambiente di test ed eseguire un ripristino bare metal. Ciò eliminerà molta pressione quando alla fine sarà necessario completare la pratica in una situazione di vita reale con i responsabili e alcune dozzine di utenti finali che contano i tempi di inattività. In tal caso, 10 minuti per capire le cose possono sembrare un'eternità e far sudare.

Note- Quando si utilizza dd assicurarsi di NON confondere i volumi di origine e di destinazione. È possibile distruggere dati e server avviabili copiando la posizione di backup su un'unità di avvio. O forse, peggio ancora, distruggere i dati per sempre copiando i dati a un livello molto basso con DD.

Di seguito sono riportati i parametri e le opzioni della riga di comando comuni per dd -

Interruttore	Azione
se =	Nel file o nella sorgente da copiare
di =	File out o la copia del file in
bs	Imposta la dimensione del blocco di input e output
oss	Imposta la dimensione del blocco del file di output
IBS	Imposta la dimensione del blocco del file di input
contare	Imposta il numero di blocchi da copiare
conv	Opzioni extra da aggiungere per l'imaging
Nessun errore	Non interrompere l'elaborazione di un errore
sincronizzazione	Blocchi di ingresso pastiglie non montate in caso di errore o disallineamento

Note on block size- La dimensione del blocco predefinita per dd è 512 byte. Questa era la dimensione del blocco standard dei dischi rigidi a densità inferiore. Gli odierni HDD a densità più elevata sono aumentati a 4096 byte (4kB) di dimensioni dei blocchi per consentire dischi da 1 TB e superiori. Pertanto, dovremo controllare la dimensione del blocco del disco prima di utilizzare dd con dischi rigidi più recenti e di maggiore capacità.

Per questo tutorial, invece di lavorare su un server di produzione con dd , utilizzeremo un'installazione CentOS in esecuzione in VMWare. Configureremo anche VMWare per avviare un'immagine ISO Linux avviabile invece di lavorare con una chiavetta USB avviabile.

Innanzitutto, dovremo scaricare l'immagine CentOS intitolata: CentOS Gnome ISO . Si tratta di quasi 3 GB e si consiglia di conservarne sempre una copia per la creazione di chiavette USB avviabili e l'avvio in installazioni di server virtuali per la risoluzione dei problemi e immagini bare metal.

Altre distribuzioni Linux avviabili funzioneranno altrettanto bene. Linux Mint può essere utilizzato per ISO avviabili in quanto ha un ottimo supporto hardware e strumenti del disco GUI lucidati per la manutenzione.

L'immagine avviabile di CentOS GNOME Live può essere scaricata da: http://buildlogs.centos.org/rolling/7/isos/x86_64/CentOS-7-x86_64-LiveGNOME.iso

Configuriamo la nostra installazione VMWare Workstation per l'avvio dalla nostra immagine avviabile di Linux. I passaggi sono per VMWare su OS X. Tuttavia, sono simili su VMWare Workstation su Linux, Windows e persino Virtual Box.

Note- L'utilizzo di una soluzione desktop virtuale come Virtual Box o VMWare Workstation è un ottimo modo per configurare scenari di laboratorio per l'apprendimento delle attività di amministrazione di CentOS. Offre la possibilità di installare diverse installazioni CentOS, praticamente nessuna configurazione hardware che consente alla persona di concentrarsi sull'amministrazione e persino di salvare lo stato del server prima di apportare modifiche.

Per prima cosa configuriamo un cd-rom virtuale e alleghiamo la nostra immagine ISO per l'avvio invece dell'installazione del server CentOS virtuale -

Ora, imposta il disco di avvio -

Ora, una volta avviata, la nostra macchina virtuale si avvierà dall'immagine ISO avviabile di CentOS e consentirà l'accesso ai file sul server Virtual CentOS precedentemente configurato.

Controlliamo i nostri dischi per vedere da dove vogliamo copiare l'MBR (l'output condensato è il seguente).

MiNt ~ # fdisk -l
Disk /dev/sda: 60 GiB, 21474836480 bytes, 41943040 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

Disk /dev/sdb: 20 GiB, 21474836480 bytes, 41943040 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

Abbiamo individuato entrambi i nostri dischi fisici: sda e sdb . Ciascuno ha una dimensione del blocco di 512 byte. Quindi, ora eseguiremo il comando dd per copiare i primi 512 byte per il nostro MBR su SDA1.

Il modo migliore per farlo è:

[root@mint rdc]# dd if=/dev/sda bs=512 count=1  | gzip -c >
/mnt/sdb/images/mbr.iso.gz 
1+0 records in 
1+0 records out 
512 bytes copied, 0.000171388 s, 3.0 MB/s

[root@mint rdc]# ls /mnt/sdb/ 
   mbr-iso.gz
   
[root@mint rdc]#

Proprio così, abbiamo un'immagine completa del nostro record di avvio principale. Se abbiamo abbastanza spazio per visualizzare l'unità di avvio, potremmo facilmente creare un'immagine di avvio completa del sistema -

dd if=/dev/INPUT/DEVICE-NAME-HERE conv=sync,noerror bs=4K | gzip -c >
/mnt/sdb/boot-server-centos-image.iso.gz

Il conv = sync viene usato quando byte devono essere allineate per un supporto fisico. In questo caso, dd potrebbe ricevere un errore se gli allineamenti 4K esatti non vengono letti (diciamo ... un file che è solo 3K ma richiede almeno un singolo blocco 4K su disco. Oppure, c'è semplicemente un errore di lettura e il file non può essere letto da dd.). Pertanto, dd con conv = sync, noerror riempirà il 3K con dati banali ma utili al supporto fisico negli allineamenti di blocchi 4K. Pur non presentando un errore che potrebbe terminare un'operazione di grandi dimensioni.

Quando lavoriamo con i dati dai dischi, vogliamo sempre includere: conv = sync, noerror parameter.

Questo è semplicemente perché i dischi non sono flussi come i dati TCP. Sono costituiti da blocchi allineati a una certa dimensione. Ad esempio, se abbiamo blocchi da 512 byte, un file di soli 300 byte necessita ancora di 512 byte di spazio su disco (possibilmente 2 blocchi per informazioni sull'inode come permessi e altre informazioni sul file system).

Usa gzip e tar per l'archiviazione sicura

gzip e tar sono due utilità a cui un amministratore di CentOS deve abituarsi. Sono usati per molto di più che per decomprimere semplicemente gli archivi.

Utilizzo di Gnu Tar in CentOS Linux

Tar è un'utilità di archiviazione simile a winrar su Windows. Il suo nome Tape Archive, abbreviato in tar, riassume praticamente l'utilità. tar prenderà i file e li inserirà in un archivio per comodità logica. Quindi, invece delle dozzine di file archiviati in / etc. potremmo semplicemente "tararli" in un archivio per comodità di backup e archiviazione.

tar è stato lo standard per l'archiviazione dei file archiviati su Unix e Linux per molti anni. Quindi, l'uso di tar insieme a gzip o bzip è considerato una best practice per gli archivi su ogni sistema.

Di seguito è riportato un elenco di opzioni e opzioni della riga di comando comuni utilizzate con tar -

Interruttore	Azione
-c	Crea un nuovo archivio .tar
-C	Estrae in una directory diversa
-j	Utilizza la compressione bzip2
-z	Utilizza la compressione gzip
-v	Verbose mostra lo stato di avanzamento dell'archiviazione
-t	Elenca i contenuti dell'archivio
-f	Nome del file dell'archivio
-X	Estrae l'archivio tar

Di seguito è riportata la sintassi di base per la creazione di un archivio tar .

tar -cvf [tar archive name]

Note on Compression mechanisms with tar- Si consiglia di attenersi a uno dei due schemi di compressione comuni quando si usa tar: gzip e bzip2. I file gzip consumano meno risorse della CPU ma di solito sono di dimensioni maggiori. Sebbene bzip2 richieda più tempo per la compressione, utilizzano più risorse della CPU; ma risulterà in una dimensione del file finale più piccola.

Quando si utilizza la compressione dei file, vorremo sempre utilizzare le estensioni di file standard per consentire a tutti, compresi noi stessi, di sapere (anziché indovinare per tentativi ed errori) quale schema di compressione è necessario per estrarre gli archivi.

bzip2	.tbz
bzip2	.tar.tbz
bzip2	.tb2
gzip	.tar.gz
gzip	.tgz

Quando è necessario estrarre gli archivi su una macchina Windows o per l'uso su Windows, si consiglia di utilizzare .tar.tbz o .tar.gz poiché la maggior parte delle estensioni a tre caratteri confonderà Windows e solo gli amministratori di Windows (tuttavia, questo è a volte il risultato desiderato)

Creiamo un archivio tar compresso con gzip dai nostri backup remoti copiati dalla workstation Mac -

[rdc@mint Documents]$ tar -cvz -f RemoteStuff.tgz ./RemoteStuff/ 
./RemoteStuff/
./RemoteStuff/.DS_Store
./RemoteStuff/DDWRT/
./RemoteStuff/DDWRT/.DS_Store
./RemoteStuff/DDWRT/ddwrt-linksys-wrt1200acv2-webflash.bin
./RemoteStuff/DDWRT/ddwrt_mod_notes.docx
./RemoteStuff/DDWRT/factory-to-ddwrt.bin
./RemoteStuff/open_ldap_config_notes/
./RemoteStuff/open_ldap_config_notes/ldap_directory_a.png
./RemoteStuff/open_ldap_config_notes/open_ldap_notes.txt
./RemoteStuff/perl_scripts/
./RemoteStuff/perl_scripts/mysnmp.pl
./RemoteStuff/php_scripts/
./RemoteStuff/php_scripts/chunked.php
./RemoteStuff/php_scripts/gettingURL.php
./RemoteStuff/A Guide to the WordPress REST API | Toptal.pdf
./RemoteStuff/Rick Cardon Tech LLC.webloc
./RemoteStuff/VeeamDiagram.png
./RemoteStuff/backbox-4.5.1-i386.iso
./RemoteStuff/dhcp_admin_script_update.py
./RemoteStuff/test_file.txt
[rdc@mint Documents]$ ls -ld RemoteStuff.tgz
-rw-rw-r--. 1 rdc rdc 2317140451 Mar 12 06:10 RemoteStuff.tgz

Note- Invece di aggiungere tutti i file direttamente all'archivio, abbiamo archiviato l'intera cartella RemoteStuff . Questo è il metodo più semplice. Semplicemente perché una volta estratto, l'intera directory RemoteStuff viene estratta con tutti i file all'interno della directory di lavoro corrente come ./currentWorkingDirectory/RemoteStuff/

Ora estraiamo l'archivio all'interno della directory / root / home.

[root@centos ~]# tar -zxvf RemoteStuff.tgz
./RemoteStuff/
./RemoteStuff/.DS_Store
./RemoteStuff/DDWRT/
./RemoteStuff/DDWRT/.DS_Store
./RemoteStuff/DDWRT/ddwrt-linksys-wrt1200acv2-webflash.bin
./RemoteStuff/DDWRT/ddwrt_mod_notes.docx
./RemoteStuff/DDWRT/factory-to-ddwrt.bin
./RemoteStuff/open_ldap_config_notes/
./RemoteStuff/open_ldap_config_notes/ldap_directory_a.png
./RemoteStuff/open_ldap_config_notes/open_ldap_notes.txt
./RemoteStuff/perl_scripts/
./RemoteStuff/perl_scripts/mysnmp.pl
./RemoteStuff/php_scripts/
./RemoteStuff/php_scripts/chunked.php
./RemoteStuff/php_scripts/gettingURL.php
./RemoteStuff/A Guide to the WordPress REST API | Toptal.pdf
./RemoteStuff/Rick Cardon Tech LLC.webloc
./RemoteStuff/VeeamDiagram.png
./RemoteStuff/backbox-4.5.1-i386.iso
./RemoteStuff/dhcp_admin_script_update.py
./RemoteStuff/test_file.txt
[root@mint ~]# ping www.google.com

Come visto sopra, tutti i file sono stati semplicemente estratti nella directory contenente all'interno della nostra directory di lavoro corrente.

[root@centos ~]# ls -l 
total 2262872 
-rw-------.   1   root   root       1752   Feb   1   19:52   anaconda-ks.cfg 
drwxr-xr-x. 137   root   root       8192   Mar   9   04:42   etc_baks 
-rw-r--r--.   1   root   root       1800   Feb   2   03:14   initial-setup-ks.cfg 
drwxr-xr-x.   6   rdc    rdc        4096   Mar  10   22:20   RemoteStuff 
-rw-r--r--.   1   root   root 2317140451   Mar  12   07:12   RemoteStuff.tgz 
-rw-r--r--.   1   root   root       9446   Feb  25   05:09   ssl.conf [root@centos ~]#

Usa gzip per comprimere i backup di file

Come notato in precedenza, possiamo usare bzip2 o gzip da tar con l'estensione -j o -zopzioni della riga di comando. Possiamo anche usare gzip per comprimere singoli file. Tuttavia, l'uso di bzip o gzip da solo non offre tante funzionalità come se combinato con tar .

Quando si utilizza gzip , l'azione predefinita è rimuovere i file originali, sostituendoli con una versione compressa aggiungendo l'estensione .gz.

Alcune opzioni della riga di comando comuni per gzip sono:

Interruttore	Azione
-c	Conserva i file dopo averli inseriti nell'archivio
-l	Ottieni statistiche per l'archivio compresso
-r	Comprime ricorsivamente i file nelle directory
-1 fino a 9	Specifica il livello di compressione su una scala da 1 a 9

gzip funziona più o meno su base file per file e non su base archivio come alcune utilità zip di Windows O / S. La ragione principale di ciò è che tar fornisce già funzionalità di archiviazione avanzate. gzip è progettato per fornire solo un meccanismo di compressione.

Quindi, quando pensi a gzip , pensa a un singolo file. Quando pensi a più file, pensa agli archivi tar . Esploriamo ora questo con il nostro precedente archivio tar .

Note - I professionisti Linux esperti faranno spesso riferimento a un archivio tarato come tarball.

Creiamo un altro archivio tar dal nostro backup rsync .

[root@centos Documents]# tar -cvf RemoteStuff.tar ./RemoteStuff/
[root@centos Documents]# ls
RemoteStuff.tar RemoteStuff/

A scopo dimostrativo, eseguiamo il gzip del tarball appena creato e diciamo a gzip di mantenere il vecchio file. Per impostazione predefinita, senza l' opzione -c , gzip sostituirà l'intero archivio tar con un file .gz .

[root@centos Documents]# gzip -c RemoteStuff.tar > RemoteStuff.tar.gz
[root@centos Documents]# ls
RemoteStuff  RemoteStuff.tar  RemoteStuff.tar.gz
We now have our original directory, our tarred directory and finally our gziped tarball.

Proviamo a testare l' opzione -l con gzip .

[root@centos Documents]# gzip -l RemoteStuff.tar.gz  
     compressed        uncompressed        ratio uncompressed_name 
     2317140467          2326661120        0.4% RemoteStuff.tar
     
[root@centos Documents]#

Per dimostrare come gzip differisce da Windows Zip Utilities, eseguiamo gzip su una cartella di file di testo.

[root@centos Documents]# ls text_files/
 file1.txt  file2.txt  file3.txt  file4.txt  file5.txt
[root@centos Documents]#

Ora usiamo l'opzione -r per comprimere ricorsivamente tutti i file di testo nella directory.

[root@centos Documents]# gzip -9 -r text_files/

[root@centos Documents]# ls ./text_files/
file1.txt.gz  file2.txt.gz  file3.txt.gz  file4.txt.gz  file5.txt.gz
 
[root@centos Documents]#

Vedere? Non quello che alcuni potrebbero aver previsto. Tutti i file di testo originali sono stati rimossi e ciascuno è stato compresso individualmente. A causa di questo comportamento, è meglio pensare a gzip da solo quando è necessario lavorare su singoli file.

Lavorando con i tarball , estraiamo il nostro tarball rsynced in una nuova directory.

[root@centos Documents]# tar -C /tmp -zxvf RemoteStuff.tar.gz
./RemoteStuff/
./RemoteStuff/.DS_Store
./RemoteStuff/DDWRT/
./RemoteStuff/DDWRT/.DS_Store
./RemoteStuff/DDWRT/ddwrt-linksys-wrt1200acv2-webflash.bin
./RemoteStuff/DDWRT/ddwrt_mod_notes.docx
./RemoteStuff/DDWRT/factory-to-ddwrt.bin
./RemoteStuff/open_ldap_config_notes/
./RemoteStuff/open_ldap_config_notes/ldap_directory_a.png
./RemoteStuff/open_ldap_config_notes/open_ldap_notes.txt
./RemoteStuff/perl_scripts/
./RemoteStuff/perl_scripts/mysnmp.pl
./RemoteStuff/php_scripts/
./RemoteStuff/php_scripts/chunked.php

Come visto sopra, abbiamo estratto e decompresso il nostro tarball nella directory / tmp.

[root@centos Documents]# ls /tmp 
hsperfdata_root
RemoteStuff

Crittografa archivi TarBall

La crittografia di archivi tarball per l'archiviazione di documenti protetti a cui potrebbe essere necessario accedere da altri dipendenti dell'organizzazione, in caso di ripristino di emergenza, può essere un concetto complicato. Ci sono fondamentalmente tre modi per farlo: o usa GnuPG, o usa openssl, o usa un'utilità di terze parti.

GnuPG è progettato principalmente per la crittografia asimmetrica e ha in mente un'associazione di identità piuttosto che una passphrase. È vero, può essere utilizzato con la crittografia simmetrica, ma questo non è il principale punto di forza di GnuPG. Pertanto, escluderei GnuPG per l'archiviazione di archivi con sicurezza fisica quando più persone della persona originale potrebbero aver bisogno di accesso (come forse un manager aziendale che vuole proteggersi da un amministratore che detiene tutte le chiavi del regno come leva).

Openssl come GnuPG può fare ciò che vogliamo e viene fornito con CentOS. Ma ancora una volta, non è specificamente progettato per fare ciò che vogliamo e la crittografia è stata messa in discussione nella comunità della sicurezza.

La nostra scelta è un'utilità chiamata 7zip. 7zip è un'utilità di compressione come gzip ma con molte più funzionalità. Come Gnu Gzip, 7zip ei suoi standard sono nella comunità open source. Dobbiamo solo installare 7zip dal nostro repository EHEL (il prossimo capitolo tratterà l'installazione dei repository aziendali estesi in dettaglio).

Installa 7zip su Centos

7zip è una semplice installazione una volta che i nostri repository EHEL sono stati caricati e configurati in CentOS.

[root@centos Documents]# yum -y install p7zip.x86_64 p7zip-plugins.x86_64
Loaded plugins: fastestmirror, langpacks
base
| 3.6 kB  00:00:00
epel/x86_64/metalink
|  13 kB  00:00:00
epel
| 4.3 kB  00:00:00
extras
| 3.4 kB  00:00:00
updates
| 3.4 kB  00:00:00
(1/2): epel/x86_64/updateinfo
| 756 kB  00:00:04      
(2/2):
epel/x86_64/primary_db
| 4.6 MB  00:00:18
Loading mirror speeds from cached hostfile
--> Running transaction check
---> Package p7zip.x86_64 0:16.02-2.el7 will be installed
---> Package p7zip-plugins.x86_64 0:16.02-2.el7 will be installed
--> Finished Dependency Resolution
Dependencies Resolved

Semplice, 7zip è installato e pronto per essere utilizzato con crittografia AES a 256 bit per i nostri archivi tarball.

Ora usiamo 7z per crittografare il nostro archivio compresso con gzip con una password. La sintassi per farlo è piuttosto semplice:

7z a -p <output filename><input filename>

Dove, a: aggiungi all'archivio e -p: crittografare e richiedere la passphrase

[root@centos Documents]# 7z a -p RemoteStuff.tgz.7z RemoteStuff.tar.gz

7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21
p7zip Version 16.02 (locale=en_US.UTF-8,Utf16=on,HugeFiles=on,64 bits,1 CPU Intel(R)
Core(TM) i5-4278U CPU @ 2.60GHz (40651),ASM,AES-NI)
Scanning the drive:
1 file, 2317140467 bytes (2210 MiB)

Creating archive: RemoteStuff.tgz.7z

Items to compress: 1

Enter password (will not be echoed):
Verify password (will not be echoed) :

Files read from disk: 1
Archive size: 2280453410 bytes (2175 MiB)
Everything is Ok
[root@centos Documents]# ls
RemoteStuff  RemoteStuff.tar  RemoteStuff.tar.gz  RemoteStuff.tgz.7z  slapD
text_files

[root@centos Documents]#

Ora, abbiamo il nostro archivio .7z che crittografa il tarball gzippato con AES a 256 bit.

Note- 7zip utilizza la crittografia AES a 256 bit con un hash SHA-256 della password e del contatore, ripetuto fino a 512K volte per la derivazione della chiave. Questo dovrebbe essere abbastanza sicuro se viene utilizzata una chiave complessa.

Il processo di crittografia e ricompressione dell'archivio può richiedere del tempo con archivi più grandi.

7zip è un'offerta avanzata con più funzionalità rispetto a gzip o bzip2. Tuttavia, non è standard con CentOS o nel mondo Linux. Pertanto, le altre utilità dovrebbero essere utilizzate il più spesso possibile.

Il sistema CentOS 7 può essere aggiornato in tre modi:

Manually
Automatically
Aggiorna manualmente per i principali problemi di sicurezza e configura gli aggiornamenti automatici

In un ambiente di produzione, si consiglia di aggiornare manualmente per i server di produzione. O almeno stabilire un piano di aggiornamento in modo che l'amministratore possa garantire servizi vitali per le operazioni aziendali.

È plausibile che un semplice aggiornamento della protezione possa causare problemi ricorsivi con un'applicazione comune che richiede l'aggiornamento e la riconfigurazione da parte di un amministratore. Quindi, stancati di pianificare gli aggiornamenti automatici in produzione prima di testare prima su server e desktop di sviluppo.

Aggiorna manualmente CentOS 7

Per aggiornare CentOS 7, vorremo acquisire familiarità con il comando yum .yumè usato per gestire i repository di pacchetti in CentOS 7. yum è lo strumento comunemente usato per:

Aggiorna il sistema Linux CentOS 7
Cerca pacchetti
Installa i pacchetti
Rileva e installa le dipendenze richieste per i pacchetti

Per poter utilizzare yum per gli aggiornamenti, il tuo server CentOS dovrà essere connesso a Internet. La maggior parte delle configurazioni installerà un sistema di base, quindi utilizzerà yum per interrogare il repository CentOS principale per funzionalità aggiuntive nei pacchetti e applicare gli aggiornamenti di sistema.

Abbiamo già utilizzato yum per installare alcuni pacchetti. Quando usi yum dovrai sempre farlo come utente root. O un utente con accesso root. Quindi cerchiamo e installiamo un editor di testo facile da usare chiamato nano .

[root@centos rdc]# yum search nano
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.rackspace.com
 * epel: mirror.chpc.utah.edu
 * extras: repos.forethought.net 
 * updates: repos.forethought.net 
====================================================================== 
      N/S matched: nano 
======================================================================
nano.x86_64 : A small text editor
nodejs-nano.noarch : Minimalistic couchdb driver for Node.js
perl-Time-Clock.noarch : Twenty-four hour clock object with nanosecond precision
 Name and summary matches only, use "search all" for everything.
 
[root@centos rdc]#

Ora installiamo l' editor di testo nano .

[root@centos rdc]# yum install nano
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.keystealth.org
 * epel: pubmirror1.math.uh.edu
 * extras: centos.den.host-engine.com
 * updates: repos.forethought.net
Resolving Dependencies
--> Running transaction check
---> Package nano.x86_64 0:2.3.1-10.el7 will be installed
--> Finished Dependency Resolution
Dependencies Resolved
================================================================================  
Package                             Arch
Version                          Repository                            Size  
================================================================================  
 Installing: 
 nano                               x86_64
 2.3.1-10.el7                    base                                  440 k
 
Transaction Summary
Install  1 Package
Total download size: 440 k
Installed size: 1.6 M
Is this ok [y/d/N]: y
Downloading packages:
nano-2.3.1-10.el7.x86_64.rpm
| 440 kB  00:00:00
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
 Installing : nano-2.3.1-10.el7.x86_64
1/1  
 Verifying  : nano-2.3.1-10.el7.x86_64
1/1  
Installed: 
 nano.x86_64 0:2.3.1-10.el7
 
Complete!

[root@centos rdc]#

Abbiamo installato l'editor di testo nano. Questo metodo, IMO, è molto più semplice della ricerca di utilità sui siti Web e dell'esecuzione manuale dei programmi di installazione. Inoltre, i repository utilizzano le firme digitali per convalidare i pacchetti assicurando che provengano da una fonte attendibile con yum. Spetta all'amministratore convalidare l'autenticità quando si fida di nuovi repository. Questo è il motivo per cui è considerata una best practice essere stanco di repository di terze parti.

Yum può essere utilizzato anche per rimuovere un pacchetto.

[root@centos rdc]# yum remove nano 
Loaded plugins: fastestmirror, langpacks 
Resolving Dependencies 
--> Running transaction check 
---> Package nano.x86_64 0:2.3.1-10.el7 will be erased 
--> Finished Dependency Resolution

Dependencies Resolved

Ora controlliamo gli aggiornamenti.

[root@centos rdc]# yum list updates
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.keystealth.org
 * epel: pubmirror1.math.uh.edu
 * extras: centos.den.host-engine.com
 * updates: repos.forethought.net
Updated Packages
NetworkManager.x86_64           1:1.4.0-17.el7_3       updates
NetworkManager-adsl.x86_64      1:1.4.0-17.el7_3       updates
NetworkManager-glib.x86_64      1:1.4.0-17.el7_3       updates
NetworkManager-libnm.x86_64     1:1.4.0-17.el7_3       updates
NetworkManager-team.x86_64      1:1.4.0-17.el7_3       updates
NetworkManager-tui.x86_64       1:1.4.0-17.el7_3       updates
NetworkManager-wifi.x86_64      1:1.4.0-17.el7_3       updates
audit.x86_64                    2.6.5-3.el7_3.1        updates
audit-libs.x86_64               2.6.5-3.el7_3.1        updates
audit-libs-python.x86_64

Come illustrato, abbiamo alcune dozzine di aggiornamenti in attesa di installazione. In realtà, ci sono circa 100 aggiornamenti totali poiché non abbiamo ancora configurato gli aggiornamenti automatici. Quindi, installiamo tutti gli aggiornamenti in sospeso.

[root@centos rdc]# yum update
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirrors.usc.edu
 * epel: pubmirror1.math.uh.edu
 * extras: repos.forethought.net
 * updates: repos.forethought.net
Resolving Dependencies
--> Running transaction check
---> Package NetworkManager.x86_64 1:1.4.0-14.el7_3 will be updated
---> Package NetworkManager.x86_64 1:1.4.0-17.el7_3 will be an update
 selinux-policy            noarch      3.13.1102.el7_3.15      updates     414 k
 selinux-policy-targeted   noarch      3.13.1102.el7_3.15      updates     6.4 M 
 systemd                   x86_64      21930.el7_3.7           updates     5.2 M 
 systemd-libs              x86_64      21930.el7_3.7           updates     369 k 
 systemd-python            x86_64      21930.el7_3.7           updates     109 k 
 systemd-sysv              x86_64      21930.el7_3.7           updates     63 k 
 tcsh                      x86_64      6.18.01-13.el7_3.1      updates     338 k 
 tzdata                    noarch      2017a1.el7              updates     443 k 
 tzdata-java               noarch      2017a1.el7              updates     182 k 
wpa_supplicant             x86_64      1:2.021.el7_3           updates     788 k  

Transaction Summary 
=============================================================================== 
  Install   2 Packages 
  Upgrade  68 Packages 
Total size: 196 M 
Total download size: 83 M 
Is this ok [y/d/N]:

Dopo aver premuto il tasto "y", inizierà l'aggiornamento di CentOS 7. Il processo generale che yum attraversa durante l'aggiornamento è:

Controlla i pacchetti correnti
Cerca nel repository i pacchetti aggiornati
Calcola le dipendenze necessarie per i pacchetti aggiornati
Scarica gli aggiornamenti
Installa gli aggiornamenti

Ora, assicuriamoci che il nostro sistema sia aggiornato -

[root@centos rdc]# yum list updates 
Loaded plugins: fastestmirror, langpacks 
Loading mirror speeds from cached hostfile 
 * updates: mirror.compevo.com

[root@centos rdc]#

Come puoi vedere, non ci sono aggiornamenti elencati.

Configurare gli aggiornamenti automatici per YUM

In un ambiente Enterprise, come accennato in precedenza, gli aggiornamenti automatici possono o meno essere il metodo di installazione preferito. Esaminiamo i passaggi per configurare gli aggiornamenti automatici con yum.

Innanzitutto, installiamo un pacchetto chiamato yum-cron .

[root@centos rdc]# yum -y install yum-cron
Install  1 Package
Total download size: 61 k
Installed size: 51 k
Downloading packages:
yum-cron-3.4.3-150.el7.centos.noarch.rpm
|  61 kB  00:00:01
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
  Installing : yum-cron-3.4.3-150.el7.centos.noarch
1/1
  Verifying  : yum-cron-3.4.3-150.el7.centos.noarch
1/1

Installed: 
 yum-cron.noarch 0:3.4.3-150.el7.centos
 
Complete!

[root@centos rdc]#

Per impostazione predefinita, yum-cron scaricherà solo gli aggiornamenti e non li installerà. L'installazione automatica degli aggiornamenti dipende dall'amministratore. L'avvertenza più grande è che alcuni aggiornamenti richiedono il riavvio del sistema. Inoltre, alcuni aggiornamenti potrebbero richiedere una modifica della configurazione prima che i servizi siano nuovamente operativi.

L'aggiornamento delle dipendenze può creare un problema ricorsivo nella seguente situazione:

Un aggiornamento è consigliato da yum per una certa libreria
La libreria supporta solo Apache Server 2.4, ma abbiamo il server 2.3
Il nostro sito commerciale si basa su una determinata versione di PHP
La nuova versione di Apache installata per la libreria richiede l'aggiornamento di PHP
Le nostre applicazioni web di produzione non sono ancora state testate con la nuova versione PHP

Yum può andare avanti e aggiornare automaticamente Apache e PHP senza preavviso a meno che non sia configurato per non farlo.

Se tutti e 5 gli scenari si verificano, può causare qualsiasi cosa, da un grande mal di testa al mattino a un possibile compromesso della sicurezza che espone i dati dell'utente. Anche se l'esempio di cui sopra è una sorta di tempesta perfetta, non vogliamo mai che uno scenario del genere si realizzi.

Spetta all'amministratore accedere a possibili scenari di potenziale perdita di entrate dal tempo necessario per ripristinare i servizi a causa di possibili tempi di inattività dovuti ai riavvii degli aggiornamenti e alle riconfigurazioni. Questa pratica potrebbe non essere abbastanza prudente per, ad esempio, un sito di e-commerce multimilionario al giorno con milioni di clienti.

Ora configuriamo yum-cron per installare automaticamente gli aggiornamenti di sistema.

[root@centos rdc]# vim /etc/yum/yum-cron.conf
# Whether updates should be applied when they are available.  Note
# that download_updates must also be yes for the update to be applied.
apply_updates = yes

Vogliamo cambiare apply_updates = no in apply_updates = yes . Ora configuriamo l'intervallo di aggiornamento per yum-cron .

Anche in questo caso, se utilizzare gli aggiornamenti automatici e installare gli aggiornamenti su richiesta può essere un'arma a doppio taglio e deve essere considerato da un amministratore per ogni situazione unica.

Introduzione a Bash Shell

Come le versioni di GNU Linux, le shell sono disponibili in molte varietà e variano in compatibilità. La shell predefinita in CentOS è nota come Bash o Bourne Again Shell. La shell Bash è una versione moderna e modificata di Bourne Shell sviluppata da Stephen Bourne. Bash è stato il sostituto diretto della Thompson Shell originale sul sistema operativo Unix sviluppato presso Bell Labs da Ken Thompson e Dennis Ritchie (Stephen Bourne era anche impiegato da Bell Labs)

Ognuno ha un guscio preferito e ognuno ha i suoi punti di forza e difficoltà. Ma per la maggior parte, Bash sarà la shell predefinita in tutte le distribuzioni Linux e più comunemente disponibile. Con l'esperienza, tutti vorranno esplorare e utilizzare una shell che è la migliore per loro. Tuttavia, allo stesso tempo, tutti vorranno anche padroneggiare la shell Bash.

Altre shell Linux includono: Tcsh, Csh, Ksh, Zsh e Fish.

Sviluppare competenze per utilizzare qualsiasi shell Linux a livello esperto è estremamente importante per un amministratore di CentOS. Come accennato in precedenza, a differenza di Windows, Linux nel suo cuore è un sistema operativo a riga di comando. Una shell è semplicemente un'interfaccia utente che consente a un amministratore (o utente) di impartire comandi al sistema operativo. Se un amministratore di sistema Linux fosse un pilota di una compagnia aerea, usare la shell sarebbe simile a togliere l'aereo dal pilota automatico e afferrare i controlli manuali per un volo più manovrabile.

Una shell Linux, come Bash, è nota in termini di informatica come Command Line Interpreter. Microsoft Windows ha anche due interpreti della riga di comando chiamati DOS (da non confondere con il sistema operativo DOS originale) e PowerShell.

Forniscono le shell più moderne come Bash constructsconsentendo a script di shell più complessi di automatizzare attività comuni e complesse.

I costrutti includono:

Controllo del flusso di script (se allora e altro)
Operazioni di confronto logico (maggiore, minore, uguaglianza)
Loops
Variables
Parametri che definiscono il funzionamento (simile agli interruttori con comandi)

Utilizzo di Shell Script rispetto al linguaggio di scripting

Spesso, quando pensano di eseguire un'attività, gli amministratori si chiedono: devo usare uno script di shell o un linguaggio di scripting come Perl, Ruby o Python?

Non esiste una regola fissa qui. Esistono solo differenze tipiche tra shell e linguaggi di scripting.

Conchiglia

Shell consente l'uso di comandi Linux come sed , grep , tee , cat e tutte le altre utilità basate sulla riga di comando sul sistema operativo Linux. In effetti, praticamente qualsiasi utilità Linux da riga di comando può essere inserita nella shell.

Un ottimo esempio di utilizzo di una shell sarebbe un rapido script per controllare un elenco di host per la risoluzione DNS.

Il nostro semplice script Bash per controllare i nomi DNS -

#!/bin/bash 
for name in $(cat $1); do host $name.$2 | grep "has address" 
   done 
exit

piccolo elenco di parole su cui testare la risoluzione DNS -

dns 
www 
test 
dev 
mail 
rdp 
remote

Output rispetto al dominio google.com -

[rdc@centos ~]$  ./dns-check.sh dns-names.txt google.com
-doing dns
dns.google.com has address 172.217.6.46
-doing www
www.google.com has address 172.217.6.36
-doing test
-doing dev
-doing mail
googlemail.l.google.com has address 172.217.6.37
-doing rdp
-doing remote

[rdc@centos ~]$

Sfruttando semplici comandi Linux nella nostra shell, siamo stati in grado di creare un semplice script di 5 righe per controllare i nomi DNS da un elenco di parole. Ciò avrebbe richiesto molto tempo in Perl, Python o Ruby anche quando si utilizzava una libreria DNS ben implementata.

Linguaggio di scripting

Un linguaggio di scripting darà più controllo al di fuori della shell. Lo script Bash precedente utilizzava un wrapper attorno al comando host Linux . E se volessimo fare di più e rendere la nostra applicazione come host per interagire al di fuori della shell? Qui è dove useremmo un linguaggio di scripting.

Inoltre, con un linguaggio di scripting altamente mantenuto, sappiamo che le nostre azioni funzioneranno per la maggior parte su sistemi diversi. Python 3.5, ad esempio, funzionerà su qualsiasi altro sistema che esegue Python 3.5 con le stesse librerie installate. Non è così, se vogliamo eseguire il nostro script BASH sia su Linux che su HP-UX.

A volte i confini tra un linguaggio di scripting e una potente shell possono essere offuscati. È possibile automatizzare le attività di amministrazione di CentOS Linux con Python, Perl o Ruby. Farlo è davvero abbastanza comune. Inoltre, i ricchi sviluppatori di script di shell hanno creato un demone del server web semplice, ma per il resto funzionale, in Bash.

Con l'esperienza nei linguaggi di scripting e nell'automazione delle attività nelle shell, un amministratore di CentOS sarà in grado di determinare rapidamente da dove iniziare quando sarà necessario risolvere un problema. È abbastanza comune avviare un progetto con uno script di shell. Quindi passare a un linguaggio di scripting (o compilato) man mano che un progetto diventa più complesso.

Inoltre, è possibile utilizzare sia un linguaggio di scripting che uno script di shell per parti diverse di un progetto. Un esempio potrebbe essere uno script Perl per raschiare un sito web. Quindi, usa uno script di shell per analizzare e formattare con sed , awk ed egrep . Infine, utilizza uno script PHP per inserire dati formattati nel database MySQL utilizzando una GUI web.

Con un po 'di teoria alla base delle shell, iniziamo con gli elementi costitutivi di base per automatizzare le attività da una shell Bash in CentOS.

Input, output e reindirizzamento

Elaborazione di stdout su un altro comando -

[rdc@centos ~]$ cat ~/output.txt | wc -l 
6039 
[rdc@centos ~]$

Sopra, abbiamo passato cat'stoud a wc per l'elaborazione con il carattere pipe . wc ha quindi elaborato l'output di cat , stampando il conteggio delle righe di output.txt sul terminale. Pensa al carattere pipe come una "pipe" che passa l'output di un comando, che deve essere elaborato dal comando successivo.

Di seguito sono riportati i concetti chiave da ricordare quando si ha a che fare con il reindirizzamento dei comandi:

Numero	Descrittore di file	Personaggio
0	input standard	<
1	output standard	>
2	errore standard
	aggiungi stdout	>>
	assegnare il reindirizzamento	&
	reindirizza stdout in stdin	\|

Lo abbiamo introdotto nel primo capitolo senza parlare molto di reindirizzamento o assegnazione di reindirizzamento. Quando si apre un terminale in Linux, la shell viene vista come destinazione predefinita per:

input standard <0
output standard> 1
errore standard 2

Vediamo come funziona -

[rdc@centos ~]$ lsof -ap $BASHPID -d 0,1,2 COMMAND PID USER **FD** TYPE DEVICE SIZE/OFF NODE NAME bash 13684 rdc **0u** CHR 136,0 0t0 3 /dev/pts/0 bash 13684 rdc **1u** CHR 136,0 0t0 3 /dev/pts/0 bash 13684 rdc **2u** CHR 136,0 0t0 3 /dev/pts/0 [rdc@centos ~]$

/ dev / pts / 0 è il nostro pseudo terminale. CentOS Linux guarda a questo e pensa alla nostra applicazione terminale aperta come un vero terminale con la tastiera e il display collegati tramite un'interfaccia seriale. Tuttavia, come un hypervisor estrae l'hardware da un sistema operativo / dev / pts astrae il nostro terminale dalle applicazioni.

Dal comando lsof sopra , possiamo vedere sottoFDcolonna che tutti e tre i descrittori di file siano impostati sul nostro terminale virtuale (0,1,2). Ora possiamo inviare comandi, vedere l'output del comando, nonché eventuali errori associati al comando.

Di seguito sono riportati esempi per STDIN e STDOUT -

STDOUT

[root@centosLocal centos]# echo "I am coming from Standard output or STDOUT." >
output.txt && cat output.txt
I am coming from Standard output or STDOUT. 
[root@centosLocal centos]#

È anche possibile inviare sia stdout che stderr a file separati -

bash-3.2# find / -name passwd 1> good.txt 2> err.txt
bash-3.2# cat good.txt
/etc/pam.d/passwd
/etc/passwd
bash-3.2# cat err.txt 
find: /dev/fd/3: Not a directory
find: /dev/fd/4: Not a directory
bash-3.2#

Durante la ricerca nell'intero file system, si sono verificati due errori. Ciascuno è stato inviato a un file separato per una successiva lettura, mentre i risultati restituiti sono stati inseriti in un file di testo separato.

L'invio di stderr a un file di testo può essere utile quando si eseguono operazioni che inviano molti dati al terminale come la compilazione di applicazioni. Ciò consentirà la lettura degli errori che potrebbero perdersi dalla cronologia di scorrimento del terminale.

Una nota quando si passa STDOUT a un file di testo sono le differenze tra >> e >. Il doppio ">>" verrà aggiunto a un file, mentre la forma singolare cancellerà il file e scriverà nuovi contenuti (così tutti i dati precedenti andranno persi).

STDIN

[root@centosLocal centos]# cat < stdin.txt
Hello,
I am being read form Standard input, STDIN.

[root@centosLocal centos]#

Nel comando precedente, il file di testo stdin.txt è stato reindirizzato al comando cat che ha ripetuto il suo contenuto su STDOUT .

Il carattere pipe "|"

Il carattere pipe prenderà l'output dal primo comando, passandolo come input nel comando successivo, consentendo al comando secondario di eseguire operazioni sull'output.

Ora, "reindirizza" lo stdout di cat a un altro comando -

[root@centosLocal centos]# cat output.txt | wc -l
2
[root@centosLocal centos]#

Sopra, wc esegue i calcoli sull'output di cat passato dal pipe. Il comando pipe è particolarmente utile quando si filtra l'output da grep o egrep -

[root@centosLocal centos]# egrep "^[0-9]{4}$" /usr/dicts/nums | wc -l  
9000 
[root@centosLocal centos]#

Nel comando precedente, abbiamo passato ogni numero di 4 cifre a wc da un file di testo contenente tutti i numeri da 65535 passati attraverso un filtro egrep .

Reindirizzamento dell'output con &

L'output può essere reindirizzato utilizzando il &personaggio. Se vogliamo indirizzare l'output sia STDOUT che STDERR, nello stesso file, può essere realizzato come segue:

[root@centosLocal centos]# find / -name passwd > out.txt 2>&1
[root@centosLocal centos]# cat out.txt  
find: /dev/fd/3: Not a directory 
find: /dev/fd/4: Not a directory 
/etc/passwd

[root@centosLocal centos]#

Reindirizzamento utilizzando il &Il carattere funziona in questo modo: in primo luogo, l'output viene reindirizzato in out.txt . Secondo, STDERR o il descrittore di file 2 viene riassegnato alla stessa posizione di STDOUT, in questo caso out.txt .

Il reindirizzamento è estremamente utile ed è utile durante la risoluzione dei problemi che sorgono durante la manipolazione di file di testo di grandi dimensioni, la compilazione del codice sorgente, il reindirizzamento dell'output negli script della shell e l'emissione di comandi Linux complessi.

Sebbene potente, il reindirizzamento può diventare complicato per i nuovi amministratori CentOS. Pratica, ricerca e domande occasionali a un forum Linux (come Stack Overflow Linux) aiuteranno a risolvere soluzioni avanzate.

Bash Shell Constructs

Ora che abbiamo una buona idea di come funziona la shell Bash , impariamo alcuni costrutti di base, comunemente usati, per scrivere script. In questa sezione esploreremo:

Variables
Loops
Conditionals
Controllo del loop
Lettura e scrittura su file
Operazioni matematiche di base

Suggerimenti per la risoluzione dei problemi BASH

BASH può essere un po 'complicato rispetto a un linguaggio di scripting dedicato. Alcuni dei più grandi blocchi negli script BASH derivano dall'escape errata o dal mancato passaggio di operazioni di script alla shell. Se hai esaminato un copione alcune volte e non funziona come previsto, non preoccuparti. Questo è comune anche a coloro che usano BASH per creare quotidianamente script complessi.

Una rapida ricerca su Google o l'iscrizione a un forum Linux esperto per porre una domanda porterà a una rapida risoluzione. È molto probabile che qualcuno si sia imbattuto nel problema esatto e che sia già stato risolto.

Lo scripting BASH è un ottimo metodo per creare rapidamente potenti script per qualsiasi cosa, dall'automazione delle attività di amministrazione alla creazione di strumenti utili. Diventare uno sviluppatore di script BASH di livello esperto richiede tempo e pratica. Quindi, usa gli script BASH quando possibile, è un ottimo strumento da avere nella tua casella degli strumenti di amministrazione di CentOS.

La gestione dei pacchetti in CentOS può essere eseguita in due modi: dal terminale e dall'interfaccia utente grafica.

Il più delle volte la maggior parte del tempo di un amministratore di CentOS utilizzerà il terminale. L'aggiornamento e l'installazione dei pacchetti per CentOS non è diverso. Con questo in mente, esploreremo prima la gestione dei pacchetti nel terminale, quindi toccheremo l'utilizzo dello strumento grafico di gestione dei pacchetti fornito da CentOS.

Gestore pacchetti YUM

YUM è lo strumento fornito per la gestione dei pacchetti in CentOS. Abbiamo toccato brevemente questo argomento nei capitoli precedenti. In questo capitolo, lavoreremo da un'installazione CentOS pulita. Per prima cosa aggiorneremo completamente la nostra installazione e quindi installeremo un'applicazione.

YUM ha portato l'installazione e la gestione del software in Linux molto lontano. YUM verifica "automaticamente" la presenza di dipendenze obsolete, oltre a pacchetti obsoleti, cosa che ha davvero tolto un carico all'amministratore di CentOS rispetto ai vecchi tempi in cui si compilava ogni applicazione dal codice sorgente.

yum check-update

Verifica la presenza di pacchetti in grado di aggiornare i candidati. Per questo tutorial, supporremo che si tratti di un sistema di produzione che affronterà Internet senza applicazioni di produzione che devono essere testate da DevOps prima di aggiornare i pacchetti. Ora installiamo i candidati aggiornati nel sistema.

[root@localhost rdc]# yum check-update
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.scalabledns.com
 * extras: mirror.scalabledns.com
 * updates: mirror.clarkson.edu
NetworkManager.x86_64                     1:1.4.0-19.el7_3              updates
NetworkManager-adsl.x86_64                1:1.4.0-19.el7_3              updates 
NetworkManager-glib.x86_64                1:1.4.0-19.el7_3              updates 
NetworkManager-libnm.x86_64               1:1.4.0-19.el7_3              updates 
NetworkManager-team.x86_64                1:1.4.0-19.el7_3              updates 
NetworkManager-tui.x86_64                 1:1.4.0-19.el7_3              updates 
NetworkManager-wifi.x86_64                1:1.4.0-19.el7_3              updates 
audit.x86_64                              2.6.5-3.el7_3.1               updates    
vim-common.x86_64                         2:7.4.160-1.el7_3.1           updates 
vim-enhanced.x86_64                       2:7.4.160-1.el7_3.1           updates 
vim-filesystem.x86_64                     2:7.4.160-1.el7_3.1           updates 
vim-minimal.x86_64                        2:7.4.160-1.el7_3.1           updates 
wpa_supplicant.x86_64                     1:2.0-21.el7_3                updates 
xfsprogs.x86_64                           4.5.0-9.el7_3                 updates

[root@localhost rdc]#

aggiornamento yum

Questo installerà tutti i candidati aggiornati rendendo la tua installazione di CentOS attuale. Con una nuova installazione, questo può richiedere un po 'di tempo a seconda dell'installazione e della velocità della connessione Internet.

[root@localhost rdc]# yum update

vim-minimal                        x86_64    2:7.4.160-1.el7_3.1     updates    436 k 
wpa_supplicant                     x86_64    1:2.0-21.el7_3          updates    788 k 
xfsprogs                           x86_64    4.5.0-9.el7_3           updates    895 k  

Transaction Summary 
======================================================================================
Install    2 Packages 
Upgrade  156 Packages  
Total download size: 371 M

Is this ok [y/d/N]:

Installa il software tramite YUM

Oltre ad aggiornare il sistema CentOS, il gestore di pacchetti YUM è il nostro strumento di riferimento per l'installazione del software. Tutto, dagli strumenti di monitoraggio della rete, ai lettori video, agli editor di testo può essere installato da un repository centrale con YUM .

Prima di installare alcune utilità software, diamo un'occhiata ad alcuni comandi YUM . Per il lavoro quotidiano, il 90% dell'utilizzo di YUM da parte di un amministratore di CentOS sarà con circa 7 comandi. Esamineremo ciascuno nella speranza di acquisire familiarità con il funzionamento di YUM a un livello competente per l'uso quotidiano. Tuttavia, come la maggior parte delle utilità Linux, YUM offre una vasta gamma di funzionalità avanzate che sono sempre fantastiche da esplorare tramite la pagina man. Usare man yum sarà sempre il primo passo per eseguire operazioni non familiari con qualsiasi utility Linux.

Comandi YUM più comuni

Di seguito sono riportati i comandi YUM comunemente usati.

Comando	Azione
elenco installato	Elenca i pacchetti installati tramite YUM
elenca tutto	Elenca tutti i pacchetti attualmente disponibili
elenco dei gruppi	Elenca i pacchetti raggruppati
Informazioni	Fornisce informazioni dettagliate su un pacchetto
ricerca	Cerca descrizioni e nomi dei pacchetti
installare	Installa un pacchetto
localinstall	Installa un pacchetto rpm locale
rimuovere	Rimuove e installa il pacchetto
pulisci tutto	Pulisce / var / cache / yum per liberare spazio su disco
uomo yum	Come tutti i comandi di Linux, il file della guida

Installa il software con YUM

Ora installeremo un browser web basato su testo chiamato Lynx. Prima dell'installazione, dobbiamo prima ottenere il nome del pacchetto contenente il browser web Lynx. Non siamo nemmeno sicuri al 100% che il nostro repository CentOS predefinito fornisca un pacchetto per il browser Web Lynx, quindi cerchiamo e vediamo -

[root@localhost rdc]# yum search web browser
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.scalabledns.com
 * extras: mirror.scalabledns.com 
 * updates: mirror.clarkson.edu 
=================================================================
N/S matched: web, browser
================================================================== 
icedtea-web.x86_64 : Additional Java components for OpenJDK - Java browser
plug-in and Web Start implementation
elinks.x86_64 : A text-mode Web browser
firefox.i686 : Mozilla Firefox Web browser
firefox.x86_64 : Mozilla Firefox Web browser
lynx.x86_64 : A text-based Web browser

Full name and summary matches only, use "search all" for everything.
 
[root@localhost rdc]#

Vediamo, CentOS offre il browser Web Lynx nel repository. Vediamo qualche informazione in più sul pacchetto.

[root@localhost rdc]# lynx.x86_64
bash: lynx.x86_64: command not found...
[root@localhost rdc]# yum info lynx.x86_64
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.scalabledns.com
 * extras: mirror.scalabledns.com
 * updates: mirror.clarkson.edu
Available Packages
Name        : lynx
Arch        : x86_64
Version     : 2.8.8
Release     : 0.3.dev15.el7
Size        : 1.4 M
Repo        : base/7/x86_64
Summary     : A text-based Web browser
URL         : http://lynx.isc.org/
License     : GPLv2
Description : Lynx is a text-based Web browser. Lynx does not display any images, 
            : but it does support frames, tables, and most other HTML tags. One 
            : advantage Lynx has over graphical browsers is speed; Lynx starts and
            : exits quickly and swiftly displays web pages.
            
[root@localhost rdc]#

Bello! La versione 2.8 è abbastanza attuale quindi installiamo Lynx.

[root@localhost rdc]# yum install lynx
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
 * base: mirror.scalabledns.com
 * extras: mirror.scalabledns.com
 * updates: mirror.clarkson.edu 
Resolving Dependencies
--> Running transaction check 
---> Package lynx.x86_64 0:2.8.8-0.3.dev15.el7 will be installed 
--> Finished Dependency Resolution  
Dependencies Resolved  
===============================================================================
===============================================================================
Package                          Arch
Version                       Repository                    Size 
===============================================================================
===============================================================================
Installing: 
 lynx                           x86_64
2.8.80.3.dev15.el7              base                        1.4 M

Transaction Summary
===============================================================================
===============================================================================
Install  1 Package

Total download size: 1.4 M 
Installed size: 5.4 M 
Is this ok [y/d/N]: y 
Downloading packages: 
No Presto metadata available for base
lynx-2.8.8-0.3.dev15.el7.x86_64.rpm
| 1.4 MB  00:00:10      
Running transaction check 
Running transaction test 
Transaction test succeeded 
Running transaction 
   Installing : lynx-2.8.8-0.3.dev15.el7.x86_64
1/1
   Verifying  : lynx-2.8.8-0.3.dev15.el7.x86_64
1/1

Installed: 
   lynx.x86_64 0:2.8.8-0.3.dev15.el7
Complete!

[root@localhost rdc]#

Quindi, assicuriamoci che Lynx sia stato effettivamente installato correttamente.

[root@localhost rdc]# yum list installed | grep -i lynx

lynx.x86_64                   2.8.8-0.3.dev15.el7              @base     
[root@localhost rdc]#

Grande! Usiamo Lynx per vedere come appare il Web senza "Mi piace" e belle immagini.

[root@localhost rdc]# lynx www.tutorialpoint.in

Ottimo, ora abbiamo un browser web per il nostro server di produzione che può essere utilizzato senza troppe preoccupazioni negli exploit remoti lanciati sul web. Questa è una buona cosa per i server di produzione.

Abbiamo quasi completato, tuttavia prima dobbiamo impostare questo server per consentire agli sviluppatori di testare le applicazioni. Quindi, assicuriamoci che abbiano tutti gli strumenti necessari per il loro lavoro. Potremmo installare tutto individualmente, ma CentOS e YUM lo hanno reso molto più veloce. Installiamo il pacchetto del gruppo di sviluppo .

[root@localhost rdc]# yum groups list 
Loaded plugins: fastestmirror, langpacks 
Loading mirror speeds from cached hostfile 
 * base: mirror.scalabledns.com 
 * extras: mirror.scalabledns.com 
 * updates: mirror.clarkson.edu
 
Available Groups: 
   Compatibility Libraries 
   Console Internet Tools 
   Development Tools 
   Graphical Administration Tools
   Legacy UNIX Compatibility 
   Scientific Support 
   Security Tools 
   Smart Card Support 
   System Administration Tools 
   System Management 
Done

[root@localhost rdc]#

Questo è un elenco più piccolo di gruppi di pacchetti forniti da CentOS. Vediamo cosa include il "Gruppo di sviluppo".

[root@localhost rdc]# yum group info "Development Tools" 
Loaded plugins: fastestmirror, langpacks 
There is no installed groups file. 
Maybe run: yum groups mark convert (see man yum) 
Loading mirror speeds from cached hostfile 
 * base: mirror.scalabledns.com 
 * extras: mirror.scalabledns.com 
 * updates: mirror.clarkson.edu
 
Group: Development Tools 
Group-Id: development 
Description: A basic development environment. 
Mandatory Packages: 
autoconf 
automake 
binutils 
bison

La prima schermata di output è quella vista sopra. L'intero elenco è piuttosto completo. Tuttavia, questo gruppo sarà solitamente necessario per essere installato nella sua interezza col passare del tempo. Installiamo l'intero gruppo di sviluppo.

[root@localhost rdc]# yum groupinstall "Development Tools"

Questa sarà un'installazione più grande. Una volta completato, il tuo server avrà la maggior parte delle librerie di sviluppo e dei compilatori per Perl, Python, C e C ++.

Gestione grafica dei pacchetti in CentOS

Gnome Desktop fornisce uno strumento grafico di gestione dei pacchetti chiamato Software. È abbastanza semplice da usare e diretto. Software, lo strumento di gestione dei pacchetti Gnome per CentOS può essere trovato accedendo a: Applicazioni → Strumenti di sistema → Software.

Lo strumento di gestione dei pacchetti software è diviso in gruppi che consentono all'amministratore di selezionare i pacchetti per l'installazione. Sebbene questo strumento sia ottimo per la facilità d'uso e la semplicità per gli utenti finali, YUM è molto più potente e probabilmente verrà utilizzato di più dagli amministratori.

Di seguito è riportato uno screenshot dello strumento di gestione dei pacchetti software, non progettato per gli amministratori di sistema.

Logical Volume Management (LVM)è un metodo utilizzato da Linux per gestire i volumi di archiviazione su diversi dischi rigidi fisici. Questo non deve essere confuso con RAID. Tuttavia, può essere pensato in un concetto simile come RAID 0 o J-Bod. Con LVM, è possibile avere (ad esempio) tre dischi fisici da 1 TB ciascuno, quindi un volume logico di circa 3 TB come / dev / sdb. O anche due volumi logici da 1,5 TB, 5 volumi da 500 GB o qualsiasi combinazione. Un singolo disco può anche essere utilizzato per le istantanee dei volumi logici.

Note- L'utilizzo di volumi logici aumenta effettivamente l'I / O del disco se configurato correttamente. Funziona in modo simile allo striping dei dati RAID 0 su dischi separati.

Quando si impara a conoscere la gestione dei volumi con LVM, è più facile se sappiamo qual è ogni componente di LVM. Si prega di studiare la seguente tabella per avere una solida conoscenza di ogni componente. Se necessario, usa Google per studiare. Comprendere ogni parte di un volume logico è importante per gestirli.

PV	Volume fisico	sda
PP	Partizione fisica	sda1, sda2
VG	Gruppo di volumi	Risorse fisiche in pool
LV	Volume logico	Visto come una struttura di archiviazione per il sistema operativo

UN physical volumesarà visto come / dev / sda, / dev / sdb; un disco fisico rilevato da Linux.

UN physical partitionsarà una sezione del disco partizionata da un'utilità del disco come fdisk. Tieni presente che la partizione fisica non è consigliata nelle configurazioni LVM più comuni. Esempio: il disco / dev / sda è partizionato per includere due partizioni fisiche: / dev / sda1 e / dev / sda1

Se abbiamo due dischi fisici di 1 TB ciascuno, possiamo creare un gruppo di volumi di quasi 2 TB tra i due.

Dal gruppo di volumi, possiamo creare tre volumi logici ciascuno di qualsiasi dimensione non superiore alla dimensione totale del gruppo di volumi.

Strumenti di amministrazione del disco Linux tradizionali

Prima di conoscere gli strumenti più recenti e migliori per la gestione LVM in CentOS 7, dovremmo prima esplorare strumenti più tradizionali che sono stati utilizzati per la gestione del disco Linux. Questi strumenti torneranno utili e potranno ancora essere utilizzati con gli strumenti LVM avanzati di oggi come System Storage Manager: lsblk, parted e mkfs.xfs.

Ora, supponendo di aver aggiunto un altro disco o due al nostro sistema, dobbiamo enumerare i dischi rilevati da Linux. Consiglio sempre di enumerare i dischi ogni volta prima di eseguire operazioni considerate distruttive.lsblkè un ottimo strumento per ottenere informazioni sul disco. Vediamo quali dischi rileva CentOS.

[root@localhost rdc]# lsblk
NAME         MAJ:MIN    RM    SIZE    RO    TYPE MOUNTPOINT
sda            8:0       0     20G     0        disk 
├─sda1         8:1       0      1G     0     part /boot
└─sda2         8:2       0     19G     0        part 
  ├─cl-root  253:0       0     17G     0      lvm  /
  └─cl-swap  253:1       0      2G     0      lvm  [SWAP]
    sdb       8:16       0      6G     0       disk 
    sdc       8:32       0      4G     0       disk 
    sr0       11:0       1   1024M     0       rom

Come puoi vedere, abbiamo tre dischi su questo sistema: sda, sdb e sdc.

Disk sda contiene la nostra installazione CentOS funzionante, quindi non vogliamo giocare con sda. Sia sdb che sdc sono stati aggiunti al sistema per questo tutorial. Rendiamo questi dischi utilizzabili su CentOS.

Crea un'etichetta disco

[root@localhost rdc]# parted /dev/sdb mklabel GPT
Warning: The existing disk label on /dev/sdb will be destroyed and all data on this
   disk will be lost. Do you want to continue?
Yes/No? Yes                               
[root@localhost rdc]#

Ora abbiamo un disco etichettato. Esegui semplicemente il comando parted nello stesso modo su sdc .

Crea le partizioni sul disco

Creeremo solo una singola partizione su ogni disco. Per creare partizioni, viene utilizzato nuovamente il comando parted .

[root@localhost rdc]# parted -a opt /dev/sdb mkpart primary ext4 0% 100%

Warning - Hai richiesto una partizione da 0.00B a 6442MB (settori 0..12582911).

La posizione più vicina che possiamo gestire è da 17,4kB a 1048kB (settori 34..2047).

È ancora accettabile per te?

Si No? NO

[root@localhost rdc]# parted -a opt /dev/sdc mkpart primary ext4 0% 100%

Information - Potrebbe essere necessario aggiornare / etc / fstab.

[root@localhost rdc]# lsblk                                               
NAME        MAJ:MIN   RM    SIZE    RO    TYPE MOUNTPOINT
sda           8:0      0     20G     0        disk 
├─sda1        8:1      0      1G     0      part / boot
└─sda2        8:2      0     19G     0        part 
 ├─cl-root  253:0      0     17G     0       lvm  /
 └─cl-swap  253:1      0      2G     0       lvm  [SWAP]
sdb          8:16      0      6G     0        disk 
└─sdb1       8:17      0      6G     0        part 
 sdc         8:32      0      4G     0        disk 
└─sdc1       8:33      0      4G     0        part 
sr0          11:0      1   1024M     0        rom

[root@localhost rdc]#

Come puoi vedere dall'output di lsblk, ora abbiamo due partizioni, ciascuna su sdb e sdc.

Crea il file system

Infine, prima di montare e utilizzare qualsiasi volume, è necessario aggiungere un file system. Useremo il file system XFS.

root@localhost rdc]# mkfs.xfs -f /dev/sdb1
meta-data = /dev/sdb1               isize = 512    agcount = 4, agsize = 393088 blks
            =                      sectsz = 512    attr = 2, projid32bit = 1
            =                         crc = 1      finobt = 0, sparse = 0
data        =                       bsize = 4096   blocks = 1572352, imaxpct = 25
            =                       sunit = 0      swidth = 0 blks
naming      = version 2             bsize = 4096   ascii-ci = 0 ftype = 1
log         = internal log          bsize = 4096   blocks = 2560, version = 2
            =                      sectsz = 512    sunit = 0 blks, lazy-count = 1
realtime    = none                  extsz = 4096   blocks = 0, rtextents = 0
[root@localhost rdc]# mkfs.xfs -f /dev/sdc1
meta-data   = /dev/sdc1             isize = 512    agcount = 4, agsize = 262016 blks
            =                      sectsz = 512    attr = 2, projid32bit = 1
            =                         crc = 1      finobt = 0, sparse = 0
data        =                       bsize = 4096   blocks = 1048064, imaxpct = 25
            =                       sunit = 0      swidth = 0 blks
naming      = version 2             bsize = 4096   ascii-ci = 0 ftype = 1
log         = internal log          bsize = 4096   blocks = 2560, version = 2
            =                      sectsz = 512    sunit = 0 blks, lazy-count = 1
realtime    = none                  extsz = 4096   blocks = 0, rtextents = 0

[root@localhost rdc]#

Controlliamo per assicurarci che ognuno abbia un file system utilizzabile.

[root@localhost rdc]# lsblk -o NAME,FSTYPE
NAME           FSTYPE
sda         
├─sda1         xfs
└─sda2         LVM2_member
 ├─cl-root     xfs
 └─cl-swap     swap
sdb         
└─sdb1         xfs
sdc         
└─sdc1         xfs
sr0

[root@localhost rdc]#

Ciascuno ora utilizza il file system XFS. Montiamoli, controlliamo il montaggio e copiamo un file su ciascuno.

[root@localhost rdc]# mount -o defaults /dev/sdb1 /mnt/sdb
[root@localhost rdc]# mount -o defaults /dev/sdc1 /mnt/sdc

[root@localhost ~]# touch /mnt/sdb/myFile /mnt/sdc/myFile
[root@localhost ~]# ls /mnt/sdb /mnt/sdc
 /mnt/sdb:
  myFile

 /mnt/sdc:
  myFile

A questo punto abbiamo due dischi utilizzabili. Tuttavia, saranno utilizzabili solo quando li montiamo manualmente. Per montarli all'avvio, dobbiamo modificare il file fstab . Inoltre, le autorizzazioni devono essere impostate per i gruppi che necessitano di accesso ai nuovi dischi.

Crea gruppi di volumi e volumi logici

Una delle più grandi aggiunte a CentOS 7 è stata l'inclusione di un'utilità chiamata System Storage Manager o ssm .System Storage Manager semplifica notevolmente il processo di gestione dei pool LVM e dei volumi di archiviazione su Linux.

Passeremo attraverso il processo di creazione di un semplice pool di volumi e volumi logici in CentOS. Il primo passaggio è l'installazione di System Storage Manager.

[root@localhost rdc]# yum  install system-storage-manager

Diamo un'occhiata ai nostri dischi usando il comando ssm list .

Come visto sopra, nel sistema sono installati un totale di tre dischi.

/sdba1 - Ospita la nostra installazione CentOS
/sdb1 - Montato su / mnt / sdb
/sdc1 - Montato su / mnt / sdc

Quello che vogliamo fare è creare un gruppo di volumi utilizzando due dischi (sdb e sdc). Quindi rendere disponibili al sistema tre volumi logici da 3 GB.

Creiamo il nostro gruppo di volumi.

[root@localhost rdc]# ssm create -p NEW_POOL /dev/sdb1 /dev/sdc1

Per impostazione predefinita, ssm creerà un unico volume logico che estende tutti i 10 GB del pool. Non lo vogliamo, quindi rimuoviamolo.

[root@localhost rdc]# ssm remove /dev/NEW_POOL/lvol001
 Do you really want to remove active logical volume NEW_POOL/lvol001? [y/n]: y
 Logical volume "lvol001" successfully removed
[root@localhost rdc]#

Infine, creiamo i tre volumi logici.

[root@localhost rdc]# ssm create -n disk001 --fs xfs -s 3GB -p NEW_POOL
[root@localhost rdc]# ssm create -n disk002 --fs xfs -s 3GB -p NEW_POOL
[root@localhost rdc]# ssm create -n disk003 --fs xfs -s 3GB -p NEW_POOL

Ora controlliamo i nostri nuovi volumi.

Ora abbiamo tre volumi logici separati distribuiti su due partizioni del disco fisico.

I volumi logici sono una potente funzionalità ora incorporata in CentOS Linux. Abbiamo toccato la superficie sulla gestione di questi. La padronanza di pool e volumi logici viene fornita con la pratica e l'apprendimento esteso da Tutorials Point. Per ora, hai imparato le basi della gestione di LVM in CentOS e possiedi la capacità di creare volumi logici con striping di base su un singolo host.