LINUX Admin I

Ubuntu Server

Netzwerk konfigurieren

VMWare-Netzwerkkarten hinzufügen

Um den Ubuntu-Server für seine zukünftigen Rollen vorzubereiten, müssen wir zuerst das Netzwerk der VM konfigurieren.

Wir benötigen einmal eine Netzwerkkarte, die als Bridge (Verbindung mit physischen Netzwerk wird hergestellt) konfiguriert ist und eine weitere Netzwerkkarte, die als Host-only (erlaubt lediglich eine Kommunikation aller virtuellen Hosts untereinander) konfiguriert ist.

Dies legen wir innerhalb von der VMWare-Maschine fest unter den Einstellungen:

Mithilfe von „Add“ fügt man eine Netzwerkkarte hinzu und gibt den Typ an.

Netzwerkkarten in Ubuntu konfigurieren

Nun wurden beide Netzwerkkarten des System hinzugefügt, diese können nun auch theoretisch genutzt werden.

Jedoch wurde noch nicht das Interface konfiguriert, daher kann noch keine Kommunikation über die neue Netzwerkkarte aufgebaut werden.

Innerhalb der interface-Datei müssen wir die Einträge hinzufügen bzw. ändern.

Befehl: sudo nano /etc/network/interfaces

Drei Einträge sind festgelegt:

  1. Loopback – wird zum Selbsttest der Netzwerkkarte verwendet, diverse Dienste und Programme benötigen das Loopback-Device, daher definiert man es auch immer
  2. eth0 (primäres Interface) „BRIDGE“ – um Internetverbindung von physischen Netz zu bekommen
  3. eth1 „INTERN“ – das neue interne Netz (für DNS und DHCP)
    1. zwei Gründe, weshalb es statisch ist:
      1. bei der Vergabe der IP-Adresse durch DHCP kann sich diese immer verändern – dadurch wäre der Server für die Clients nicht mehr erreichbar
      2. im internen Netzwerk ist noch kein DHCP-Server vorhanden, welcher Adresse verteilen könnte (diese Rolle übernimmt der Server dann später selbst)

Argumente:

  • auto – legt fest, dass das nachfolgende Interface beim Laden der Netzwerkkonfiguration automatisch aktiviert werden soll.
  • inet – beschreit das verwendete Verbindungsprotokoll (hier IPv4)
    • es stehen auch IPv6 (inet6) und IPX/SPX (ipx) zur Verfügung
  • static – bedeutet, dass dem Interface eine statische IP-Adresse vergeben wird
  • dhcp – ist hier nun nicht der Fall, jedoch wenn man diese Methode einträgt, bekommt das Interface automatisch eine IP-Adresse

Abschließend starten wir den networking Service neu

Befehl: sudo service networking restart

Befehl: sudo /etc/init.d/networking restart

Konfiguration testen

Zum Schluss überprüfen wir noch, ob die Konfiguration der Interfaces auch richtig übernommen wurde

Befehl: ifconfig

DHCP installieren

Was ist DHCP?

Das Dynamic Host Configuration Protocol (DHCP) ist ein Netzwerkdienst, der in der Lage ist, Netzwerkrechnern automatisch Einstellungen zuzuweisen statt jeden Rechner einzeln manuell zu konfigurieren. Rechner, die als DHCP-Clients konfiguriert werden, haben keine Kontrolle über die Einstellungen, die sie vom DHCP-Server erhalten. Weiterhin sind diese Einstellungen für den Benutzer des Rechners nicht sichtbar.

Die gebräuchlichsten Einstellungen, die ein DHCP-Server einem DHCP-Client zuordnet, sind:

  1. IP-Adresse und Netzmaske
  2. IP address of the default-gateway to use
  3. IP adresses of the DNS servers to use

Allerdings kann ein DHCP-Server auch Konfigurationseigenschaften bereitstellen wie:

  1. Rechnername
  2. Domänenname
  3. Uhrzeit-Server
  4. Drucker-Server

Installation

Zuerst müssen wir die Rolle/den Dienst installieren.

Befehl: sudo apt-get install isc-dhcp-server

DHCP-Bereich festlegen – konfigurieren

Dazu müssen wir die Konfigurations-Datei von DHCP bearbeiten.

Diese finden wir unter /etc/dhcp/dhcpd.conf

Befehl: sudo nano /etc/dhcp/dhcpd.conf

Innerhalb der Datei geben wir nun die DHCP-Range an – insgesamt geben wir im Subnetz 10.0.0.0  100 freie IP-Adressen an

Dem DHCP-Dienst muss ein Subnetz und die zugehörige Subnetmask zugewiesen werden, für das der Dienst zuständig sein soll.

Innerhalb der {}-Klammern befinden sich Argumente die Einstellungen des DHCP-Leases betreffen.

Die Range bestimmt den Adressbereich indem die IP-Adressen vom DHCP-Server verteilt werden.

Argumente:

  • Authoritative – ist eine Sicherheitsvorkehrung diese Einstellung soll verhindern, dass ein zweiter DHCP-Server, der sich böswillig oder durch eine Fehlkonfiguration im Netzwerk befindet, IP-Adressen an die Clients vergibt (Spoofing)
  • Lease-Time – bestimmt, wie lange die zugewiesene IP-Adresse und NW-Konfiguration eines Clients gültig ist (in Sekunden)
  • option – weitere Netzwerkeinstellungen wie BC-Adresse, Subnetmask und DNS-Server können an die Clients verteilt werden

DHCP-Server an Interface binden

Es ist außerdem noch wichtig, den DHCP-Server an ein Interface zu binden, um Spoofing von anderen Netzwerken zu verhindern.

Um davon sicher zugehen, nimmt man die Einstellung in der isc-dhcp-server-Datei vor. Einfach das richtige Interface eintragen.

Befehl: sudo nano /etc/default/isc-dhcp-server

DHCP neustarten

Nach der Konfiguration werden wir den DHCP-Service neustarten, damit die neue Konfiguration auch übernommen wird.

Befehl: sudo service isc-dhcp-server restart

Clients einbinden

Nun wollen wir einen Client von unserem konfigurierten DHCP-Server die IP-Adresse & Konfiguration vergeben lassen. Dies müssen wir ebenfalls nur in der interfaces-Datei von unserem Client angeben.

Der Netzwerkadapter (eth0) wird im DHCP-Modus betrieben. Alle weiteren Angaben sind nicht notwendig, weil alles vom DHCP bezogen wird.

Nun speichert man die Konfiguration und startet den Dienst networking neu.

Nachdem der Service wieder gestartet ist, überprüfen wir, ob der Client auch die IP-Adresse bekommen hat mit ifconfig.

DNS installieren – BIND9

Was ist BIND?

BIND ist ein von der Universität Berkeley (USA) entwickelter DNS-Server, der eine hohe Verbreitung in mittleren bis großen Netzen findet. Er ist als Open Source erhältlich und wurde auf fast jedes Betriebssystem portiert. Bis heute gilt BIND als „die Referenz“ unter den DNS-Servern und bildet den Grundstock des heutigen Internets.

Als alternativer DNS-Server für kleinere (Heim-)Netze steht auch Dnsmasq zur Verfügung, der besonders einfach konfiguriert werden kann.

Installation

Befehl: sudo apt-get install bind9

Anfangs hat der Server noch keine sinnvolle Konfiguration, daher stoppen wir ihn vorerst:

Befehl: sudo /etc/init.d/bind9 stop

FQDN setzen

Wir müssen für die DNS-Konfiguration dem Server einen FQDN vergeben. Dies wird in der hosts-Datei festgelegt.

Befehl: sudo nano /etc/hosts

Einfach bei dem eingetragenen Hostnamen die gewünschte Domain anhängen (schulreich.local) und dann noch den eigentlichen Hostnamen noch hinten hinzufügen.

Konfiguration des primären DNS-Servers

Diese erfolgt über das Verzeichnis /etc/bind.

Bei korrekter Installation befinden sich folgende Dateien darin:

db.0 db.local named.conf zones.rfc1918

db.127 db.root named.conf.local rndc.key

db.255 db.empty named.conf.options

Dateien mit

  • named beginnend  hier wird die allgemeine Funktion des Server konfiguriert
  • db.  die Zonendateien, in denen die eigentlichen DNS-Daten abgelegt werden

Anlegen neuer Zonendateien

Zwei neue db.-Dateien müssen erstellt werden

  • db.domainname  Forwardlookup-Zone
    • sorgt für die Auflösung von Hostnamen in IP-Adressen
  • db.z.y.x  Reverselookup-Zone
    • das ist die Auflösung in umgekehrter Reihenfolge, also IP-Adresse  Hostname

Forward-Lookup-Zone könnte so aussehen:

;; db.domainname

;; Forwardlookupzone für domainname

;;

$TTL 2D

@ IN SOA rechnername.domainname. mail.domainname. (

2006032201 ; Serial

8H ; Refresh

2H ; Retry

4W ; Expire

3H ) ; NX (TTL Negativ Cache)

@ IN NS rechnername.domainname.

IN MX 10 mailserver.domainname.

IN A 192.168.0.10

rechnername IN A 192.168.0.10

localhost IN A 127.0.0.1

rechner1 IN A 192.168.0.200

mailserver IN A 192.168.0.201

rechner2 IN CNAME mailserver

Ressourcen von MX-Records (in diesem Beispiel also der „mailserver“) müssen immer auf einen A-Record verweisen (RFC 2181).

Besonders wichtig an dieser Stelle ist eine Leerzeile am Ende der Datei!

Das TTL (time to live) gibt an, wie lange Informationen im Cache gültig bleiben und danach neu angefordert werden (in diesem Fall 2Days also 2 Tage).

Als nächstes kommt dann der SOA (start of authority resource records), welcher folgende Werte für den Bereich der Domäne festlegt:

  • zone-origin ist der vollqualifizierte Domainname (FQDN) des primären DNS-Servers. (In diesem Fall server.domainname., der Name des Servers, den gerade konfigurieren wird.) Der Punkt am Ende ist übrigens wichtig!
  • zone-contact ist die Mail-Adresse des DNS-Verwalters. Das „@“ wird hier jedoch durch einen Punkt ersetzet, somit müsste hier „mail.domainname.“ eingetragen werden. Auch hier den Punkt am Ende nicht vergessen!
  • serial ist eine Seriennummer, die der Administrator nach seinen Vorstellungen vergeben kann. Allerdings muss die Seriennummer bei jeder Änderung erhöht werden, da diese Nummer sekundären DNS-Servern als Indiz dafür dient, dass sich was geändert hat. Nach allgemeiner Konvention benutzt man deswegen die Form YYYYMMDDSS, mit YYYY=Jahr, MM=Monat, DD=Tag und SS=zweistellige Seriennummer, die bei mehreren Änderungen an einem Tag jeweils um eins erhöht wird.

Die folgenden Einträge des SOA-Abschnitts befinden sich für die meisten Fälle schon auf vernünftigen Voreinstellungen und müssen im Allgemeinen nicht angetastet werden.

Experten-Info:

  • refresh gibt die Zeit in Sekunden an, die ein sekundärer Server wartet, bis er beim primären Server nachfragt, ob sich die Zonendateien verändert haben.
  • retry gibt die Zeit in Sekunden an, die ein sekundärer Server wartet, bis er eine Anfrage an den primären Server wiederholt, wenn dieser auf die vorherige Anfrage nicht geantwortet haben sollte (z.B. weil er offline war).
  • expire gibt die Zeit in Sekunden an, die ein sekundärer Server auf einen erfolgreichen Kontakt zum primären Server wartet, bevor er die Zonendatei für ungültig erklärt.
  • nx gibt die Zeit an, während der eine negativ beschiedene DNS Anfrage („Name Error“ / „NXDOMAIN“) zwischengespeichert werden soll (zwischen 0 Sekunden und 3 Stunden).

Als nächstes kommen die Einträge der DNS-Server, die für die Zone verantwortlich sind. Diese haben alle die Form

Name IN RR Wert

Der Name kann dabei weggelassen werden, in welchem Fall er aus der vorherigen Zeile übernommen wird. Namen ohne Punkt am Ende werden dabei durch den Zonen-(Domain-)namen ergänzt, Namen mit Punkt gelten als vollqualifiziert. Ein besonderer Name ist das Zeichen @, das dem Zonennamen entspricht.

RR (Resource Record) muss einer von mehreren offiziellen RR-Bezeichnungen sein und der Wert hängt von der Art des RR ab. Einige RRs:

RR Wert Beschreibung
NS FQDN eines DNS-Servers alle primären und sekundären DNS-Server der Domain sollten einen Eintrag besitzen
A IP-Adresse „normaler“ Eintrag: Name -> IP
CNAME richtiger Name Alias-Definition – richtiger Name muss kein FQDN sein, sollte aber kein weiterer CNAME sein
MX Priorität Name Mailserver, der Mail für die Domain annimmt – Priorität muss eine Zahl sein (niedriger: zuerst probieren), Name ist der Name des Mailservers
PTR FQDN umgekehrte Auflösung: IP -> Name

Reverse-Lookup-Zone könnte so aussehen:

;; db.0.168.192

;; Reverselookupzone für domainname

;;

$TTL 2D

@ IN SOA rechnername.domainname. mail.domainname. (

2006032201 ; Serial

8H ; Refresh

2H ; Retry

4W ; Expire

2D ) ; TTL Negative Cache

@ IN NS rechnername.domainname.

10 IN PTR rechnername.domainname.

200 IN PTR rechner1.domainname.

201 IN PTR rechner2.domainname.

Man beachte die PTR-Records, die für die Rückwärtsübersetzung von IP-Adressen in Namen zuständig sind. Die Zahlen in der ersten Spalte stellen dabei das letzte Byte der IP-Adresse dar. Wichtig ist, dass die übersetzten Namen FQDNs (mit Punkt am Ende) sind.

Alias-Einträge, MX-Records, etc. werden hier nicht nochmal aufgeführt

Globale Konfiguration in named.conf

Nun müssen die Zonendateien dem Server noch bekannt gemacht werden. Dies geschieht durch folgenden Eintrag in der Datei named.conf.local, die in der eigentlichen named.conf-Datei referenziert wird:

zone „domainname“ {

type master;

file „/etc/bind/db.domainname“;

};

zone „0.168.192.in-addr.arpa“ {

type master;

file „/etc/bind/db.0.168.192“;

};

.in-addr.arpa ist die offizielle „Domain für IP-Adressen“. Diese sind pro Byte in Subdomains aufgeteilt. 0.168.192.in-addr.arpa ist also die Subdomain für alle Adressen von 192.168.0.0 bis 192.168.0.255. Diese Bezeichnung aus der zone-Direktive ist auch gleichzeitig das, was in den Zonendateien als @ referenziert werden kann.

Die Option master sagt dem Server, dass er der für die Domain verantwortliche Server ist, also der primäre Server und das file verweist lediglich noch auf die Zonendateien.

Konfiguration testen

Nun da alles konfiguriert ist, müssen wir den bind9-Service nur noch einmal neustarten.

Wenn der Service wieder gestartet ist, kann man die Einträge nun mit nslookup testen.

Firewall

Netzwerke tauschen durchgehend Informationen aus. Grundsätzlich ist dies alles sehr nützlich, jedoch kann es auch zu Verbindungen in einem Netzwerk kommen, die unerwünscht sind.

Die Firewall ist dafür hier um den Datenverkehr zu überwachen und zu kontrollieren. Sie stellen eine durchaus wichtige Sicherheitsinstanz im Netzwerk dar und gehören immer zu einer guten Netzwerkkonfiguration dazu.

Im Linux-Kernle ist das Programm netfilter verankert.

Dieses erlaubt den Datenverkehr mitzulesen & zu beeinflussen hier wiederrum baut das Programm iptables auf.

In policies und chains wird festgelegt welche Verbindungen akzeptiert oder welche abgelehnt werden.

Bekannte Ausdrücke der Firewall-Konfiguration:

  • Regeln: werden von chains oder policies aufgerufen, um Pakete abzufertigen
    • Accept: Das Paket wird angenommen & zu seinem Ziel weitergeleitet
    • Drop: Das Paket wird abgelehnt & verworfen
    • Reject: Das Paket wird abgelehnt & geht zurück zum Absender
  • Policy: bestimmt die Grundeinstellung der Firewall. Alle Pakete, die nicht von einer chain-Regelung betroffen sind, müssen der policy folgen.Policies kennen die Werte:
    • accept
    • drop
    • reject

Professionell eingerichtete Firewalls arbeiten nach einer restriktiven Methode alles, was nicht expliziert erlaubt ist, ist verboten.

Policies sollten daher immer auf drop/reject eingestellt sein.

  • Chain: Eine chain setzt sich aus mehreren Parametern zusammen, die Eigenschaften einer Verbindung bestimmen.
    Am Ende jeder chain befindet sich ein Regelwert (accept/drop/reject), welcher bestimmt was mit einem Paket geschieht auf das alle definierten Eigenschaften zutreffen.

Installation

Die notwendigen Programme zur Erstellung einer Firewall befinden sich bereits im Linux-Kernel. Sollte jedoch aus unbestimmten Gründen nicht im System vorhanden sein, kann das Paket iptables jederzeit durch eine Paketverwaltung installiert werden.

Befehl: apt-get install iptables

NFS

Introduction

NFS, or Network File System, is a distributed filesystem protocol that allows you to mount remote directories on your server. This allows you to leverage storage space in a different location and to write to the same space from multiple servers easily. NFS works well for directories that will have to be accessed regularly.

In this guide, we’ll cover how to configure NFS mounts on an Ubuntu 14.04 server.

Prerequisites

In this guide, we will be configuring directory sharing between two Ubuntu 14.04 servers. These can be of any size. For each of these servers, you will have to have an account set up with sudo privileges. You can learn how to configure such an account by following steps 1-4 in our initial setup guide for Ubuntu 14.04 servers.

For the purposes of this guide, we are going to refer to the server that is going to be sharing its directories the host and the server that will mount these directories as the client.

In order to keep these straight throughout the guide, I will be using the following IP addresses as stand-ins for the host and server values:

  • Host: 1.2.3.4
  • Client: 111.111.111.111

You should substitute the values above with your own host and client values.

Download and Install the Components

Before we can begin, we need to install the necessary components on both our host and client servers.

On the host server, we need to install the nfs-kernel-server package, which will allow us to share our directories. Since this is the first operation that we’re performing with apt in this session, we’ll refresh our local package index before the installation:

sudo apt-get update

sudo apt-get install nfs-kernel-server

Once these packages are installed, you can switch over to the client computer.

On the client computer, we’re going to have to install a package called nfscommon, which provides NFS functionality without having to include the server components. Again, we will refresh the local package index prior to installation to ensure that we have up-to-date information:

sudo apt-get update

sudo apt-get install nfs-common

Create the Share Directory on the Host Server

We’re going to experiment with sharing two separate directories during this guide. The first directory we’re going to share is the /home directory that contains user data.

The second is a general purpose directory that we’re going to create specifically for NFS so that we can demonstrate the proper procedures and settings. This will be located at /var/nfs.

Since the /home directory already exists, go ahead and start by creating the /var/nfs directory:

sudo mkdir /var/nfs

Now, we have a new directory designated specifically for sharing with remote hosts. However, the directory ownership is not ideal. We should give the user ownership to a user on our system namednobody. We should give the group ownership to a group on our system named nogroup as well.

We can do that by typing this command:

sudo chown nobody:nogroup /var/nfs

We only need to change the ownership on our directories that are used specifically for sharing. We wouldn’t want to change the ownership of our /home directory, for instance, because it would cause a great number of problems for any users we have on our host server.

Configure the NFS Exports on the Host Server

Now that we have our directories created and assigned, we can dive into the NFS configuration file to set up the sharing of these resources.

Open the /etc/exports file in your text editor with root privileges:

sudo nano /etc/exports

The files that you see will have some comments that will show you the general structure of each configuration line. Basically, the syntax is something like:

directory_to_share client(share_option1,…,share_optionN)

So we want to create a line for each of the directories that we wish to share. Since in this example or client has an IP of 111.111.111.111, our lines will look like this:

/home 111.111.111.111(rw,sync,no_root_squash,no_subtree_check)

/var/nfs 111.111.111.111(rw,sync,no_subtree_check)

We’ve explained everything here but the specific options we’ve enabled. Let’s go over those now.

  • rw: This option gives the client computer both read and write access to the volume.
  • sync: This option forces NFS to write changes to disk before replying. This results in a more stable and consistent environment, since the reply reflects the actual state of the remote volume.
  • nosubtreecheck: This option prevents subtree checking, which is a process where the host must check whether the file is actually still available in the exported tree for every request. This can cause many problems when a file is renamed while the client has it opened. In almost all cases, it is better to disable subtree checking.
  • norootsquash: By default, NFS translates requests from a root user remotely into a non-privileged user on the server. This was supposed to be a security feature by not allowing a root account on the client to use the filesystem of the host as root. This directive disables this for certain shares.

When you are finished making your changes, save and close the file.

Next, you should create the NFS table that holds the exports of your shares by typing:

sudo exportfs -a

However, the NFS service is not actually running yet. You can start it by typing:

sudo service nfs-kernel-server start

This will make your shares available to the clients that you configured.

Create the Mount Points and Mount Remote Shares on the Client Server

Now that your host server is configured and making its directory shares available, we need to prep our client.

We’re going to have to mount the remote shares, so let’s create some mount points. We’ll use the traditional /mnt as a starting point and create a directory called nfs under it to keep our shares consolidated.

The actual directories will correspond with their location on the host server. We can create each directory, and the necessary parent directories, by typing this:

sudo mkdir -p /mnt/nfs/home

sudo mkdir -p /mnt/nfs/var/nfs

Now that we have some place to put our remote shares, we can mount them by addressing our host server, which in this guide is 1.2.3.4, like this:

sudo mount 1.2.3.4:/home /mnt/nfs/home

sudo mount 1.2.3.4:/var/nfs /mnt/nfs/var/nfs

These should mount the shares from our host computer onto our client machine. We can double check this by looking at the available disk space on our client server:

df -h

Filesystem Size Used Avail Use% Mounted on

/dev/vda 59G 1.3G 55G 3% /

none 4.0K 0 4.0K 0% /sys/fs/cgroup

udev 2.0G 12K 2.0G 1% /dev

tmpfs 396M 324K 396M 1% /run

none 5.0M 0 5.0M 0% /run/lock

none 2.0G 0 2.0G 0% /run/shm

none 100M 0 100M 0% /run/user

1.2.3.4:/home 59G 1.3G 55G 3% /mnt/nfs/home

As you can see at the bottom, only one of our shares has shown up. This is because both of the shares that we exported are on the same filesystem on the remote server, meaning that they share the same pool of storage. In order for the Avail and Use% columns to remain accurate, only one share may be added into the calculations.

If you want to see all of the NFS shares that you have mounted, you can type:

mount -t nfs

1.2.3.4:/home on /mnt/nfs/home type nfs (rw,vers=4,addr=1.2.3.4,clientaddr=111.111.111.111)

1.2.3.4:/var/nfs on /mnt/nfs/var/nfs type nfs (rw,vers=4,addr=1.2.3.4,clientaddr=111.111.111.111)

This will show all of the NFS mounts that are currently accessible on your client machine.

Test NFS Access

You can test the access to your shares by writing something to your shares. You can write a test file to one of your shares like this:

sudo touch /mnt/nfs/home/test_home

Let’s write test file to the other share as well to demonstrate an important difference:

sudo touch /mnt/nfs/var/nfs/test_var_nfs

Look at the ownership of the file in the mounted home directory:

ls -l /mnt/nfs/home/test_home

-rw-r–r– 1 root root 0 Apr 30 14:43 test_home

As you can see, the file is owned by root. This is because we disabled the root_squash option on this mount that would have written the file as an anonymous, non-root user.

On our other test file, which was mounted with the root_squash enabled, we will see something different:

ls -l /mnt/nfs/var/nfs/test_var_nfs

-rw-r–r– 1 nobody nogroup 0 Apr 30 14:44 test_var_nfs

As you can see, this file was assigned to the „nobody“ user and the „nogroup“ group. This follows our configuration.

Make Remote NFS Directory Mounting Automatic

We can make the mounting of our remote NFS shares automatic by adding it to our fstab file on the client.

Open this file with root privileges in your text editor:

sudo nano /etc/fstab

At the bottom of the file, we’re going to add a line for each of our shares. They will look like this:

1.2.3.4:/home /mnt/nfs/home nfs auto,noatime,nolock,bg,nfsvers=4,intr,tcp,actimeo=1800 0 0

1.2.3.4:/var/nfs /mnt/nfs/var/nfs nfs auto,noatime,nolock,bg,nfsvers=4,sec=krb5p,intr,tcp,actimeo=1800 0 0

The options that we are specifying here can be found in the man page that describes NFS mounting in thefstab file:

man nfs

This will automatically mount the remote partitions at boot (it may take a few moments for the connection to be made and the shares to be available).

Unmount an NFS Remote Share

If you no longer want the remote directory to be mounted on your system, you can unmount it easily by moving out of the share’s directory structure and unmounting, like this:

cd ~

sudo umount /mnt/nfs/home

sudo umount /mnt/nfs/var/nfs

This will remove the remote shares, leaving only your local storage accessible:

df -h

Filesystem Size Used Avail Use% Mounted on

/dev/vda 59G 1.3G 55G 3% /

none 4.0K 0 4.0K 0% /sys/fs/cgroup

udev 2.0G 12K 2.0G 1% /dev

tmpfs 396M 320K 396M 1% /run

none 5.0M 0 5.0M 0% /run/lock

none 2.0G 0 2.0G 0% /run/shm

none 100M 0 100M 0% /run/user

As you can see, our NFS shares are no longer available as storage space.[1]

Apache

Was ist Apache?

Apache ist der meistgenutzte Webserver im Internet. In der Version 2 wurden besonders die Stabilität und die Geschwindigkeit des Servers verbessert. Über serverseitige Skriptsprachen wie PHP und CGI lassen sich auch dynamische Webseiten erstellen. Diese Sprachen und noch viele weitere Funktionen können über Module eingebunden werden. In Kombination mit MySQL und PHP oder Perl oder Python spricht man dann von einen LAMP-Server (Linux, Apache, MySQL und P wie PHP, Perl oder Python).

Installation

Apache 2 ist in den offiziellen Paketquellen von Ubuntu enthalten. Benötigt werden folgende Pakete:

  • apache2 (ab Ubuntu 13.10 Apache 2.4, sonst 2.2)
  • apache2-doc (optional s.u.)

Paketliste zum Kopieren: apt-get aptitude

sudo apt-get install apache2 apache2-doc

Wer PHP, CGI oder weitere Sprachen verwenden will, muss für diese Zusatzmodule noch weitere Pakete nachinstallieren.

Konfiguration

Der Apache Webserver lässt sich durch Editieren [3] der Dateien

  • /etc/apache2/apache2.conf
  • /etc/apache2/ports.conf

konfigurieren. Üblicherweise muss man hier nichts von Hand bearbeiten, es sei denn, man benötigt spezielle Konfigurationen.

Auf lokales System beschränken

Befindet sich der Rechner mit dem Server direkt im Internet – also nicht hinter einem Router – oder sollen andere Rechner aus dem lokalen Netzwerk nicht auf den Webserver zugreifen, so kann man den Zugriff über die /etc/apache2/ports.conf steuern. Trägt man z.B. anstelle von

Listen 80

die Zeile

Listen localhost:80

ein und startet den Webserver neu, so kann man den Webserver nur noch lokal ansprechen.

Sollte man versuchen, über die WAN-IP oder über eine z.B. per DynDNS {en} angelegte Domain auf den Server zu kommen, wird dies eventuell scheitern. Das kann daran liegen, dass der Router kein „NAT Loopback“ unterstützt oder dieses nicht eingeschaltet ist. Stattdessen kann man die Verfügbarkeit aus dem Internet z.B. mit einem Dienst wie Anonymouse.org {en} testen.

Virtuelle Hosts anlegen

Auf einem Apache-Webserver mit (nur) einer IP-Adresse können durchaus mehrere unabhängige Homepages, Blogs oder Wikis bereitgestellt werden. Wie dies funktioniert, ist im Artikel Apache/Virtual Hosts erklärt.

Webseiten ablegen und aufrufen

Systemweit

Die Inhalte für den Server werden in einem als „document root“ oder auch als „Webroot“ bezeichneten Verzeichnis abgespeichert. Dies bedeutet, dass der Apache Webserver dort nach den auszuliefernden (HTML-)Dateien schaut. Je nach Apache- bzw. Ubuntu-Version ist das der folgende Ordner:

  • Apache 2.4 (ab Ubuntu 13.10): /var/www/html/
  • Apache 2.2 (bis Ubuntu 13.04): /var/www/

Legt man dort Dateien ab, so können diese mit

http://localhost/ bzw. http://SERVER-IP_ODER_NAME

im Browser aufgerufen werden. Standardmäßig ist hier bereits eine einfache Demoseite index.html installiert, was für das Testen der Grundkonfiguration praktisch ist. Möchte man das „document root“ ändern, kann man einen „virtuellen Host“ verwenden.

Rechte

Falls bei einem Mehrbenutzersystem bestimmten Personen Schreibrechte für die in „document root“ enthaltenen Dateien gegeben werden soll, sollte dafür eine Gruppe angelegt werden. Dies ist nicht notwendig, wenn nur ein Mitglied der Gruppe sudo (früher admin) Inhalte erstellen oder bearbeiten soll. Diese können mit dem Befehl sudo Datei-Operationen ausführen.

Soll Nutzern ohne Root-Rechte Schreibzugriff gewährt werden, muss dafür eine Gruppe angelegt werden. Dies ist im folgenden Beispiel die Gruppe www. Dieser Name kann aber frei vergeben werden. Dieser Gruppe können Schreibrechte auf den „document root“-Ordner gegeben werden und die Nutzer hinzufügt werden.

Beispiel für Apache 2.2:

sudo groupadd www

sudo adduser BENUTZERNAME www

sudo chgrp www /var/www

sudo chmod g+w /var/www

Damit die neuen Rechte greifen, muss man sich einmal ab- und neu anmelden oder den Befehl newgrp verwenden.

Benutzerspezifisch

Darüber hinaus können auch die einzelnen Benutzer des Rechners innerhalb ihres Homeverzeichnisses Webseiten im Unterordner ~/public_html speichern. Dieser wird automatisch vom Webserver eingebunden und ist unter der URL

http://localhost/~username/ bzw. http://SERVER-IP_ODER_NAME/~username/

zu erreichen.

Das hierfür nötige Modul mod_userdir wird bei der Installation von Apache mit installiert. Es muss nur noch mit dem einmaligen Befehl

sudo a2enmod userdir # Aktivieren des Moduls

sudo /etc/init.d/apache2 reload # Neuladen der Apache Konfiguration

aktiviert werden. Danach muss man noch in der Konfigurationsdatei /etc/apache2/mods-enabled/userdir.conf den Pfad eventuell anpassen, andernfalls kann es passieren, dass die Seite nicht angezeigt wird.

<IfModule mod_userdir.c>

UserDir /home/*/public_html

UserDir disabled root

</IfModule>

Nun kann im jeweiligen Benutzer- bzw. Homeverzeichnis der Unterordner ~/public_html erstellt werden. In diesem können dann die Dateien abgelegt werden. Der übergeordnete Ordner /home/BENUTZERNAME/ braucht außerdem die Rechte 755, damit der Webserver überhaupt auf diesen Unterordner zugreifen kann.

Dabei muss man grundsätzlich beachten, dass der Benutzer www-data, unter dem Apache läuft, auf die Dateien zugreifen kann. Daher müssen die Leserechte u.U. nach dem Kopieren überprüft werden. Schreibrechte sollten nur dort gesetzt werden, wo der Webserver auch wirklich schreiben muss. Zu freizügig gesetzte Schreibrechte stellen eine Sicherheitslücke dar. Mehr zu Thema Dateirechte findet man unter „Rechte“.

Möchte man PHP nutzen, darf dies natürlich nicht abgeschaltet sein. Deshalb muss noch php_admin_value in der Datei /etc/apache2/mods-enabled/php5.conf auskommentiert werden:

<IfModule mod_userdir.c>

<Directory /home/*/public_html>

# php_admin_value engine Off

</Directory>

</IfModule>

Apache steuern

Wie alle anderen Dienste bringt Apache Start/Stop-Skripte mit. Diese Skripte lassen sich natürlich auch zum Kontrollieren des Webservers gebrauchen.

sudo /etc/init.d/apache2

  • start – startet den Webserver
  • stop – stoppt den Server
  • restart – startet den Server neu, bestehende Verbindungen auf den Server werden gekappt
  • reload – lädt die Konfigurationsdateien neu, ohne dass Verbindungen getrennt werden
  • force-reload – Lädt die Konfigurationsdateien neu, auch wenn dabei Verbindungen getrennt werden müssen
  • sudo update-rc.d -f apache2 remove – Apache2 aus der Autostartliste entfernen
  • sudo update-rc.d apache2 defaults – Apache2 wieder der Autostartliste hinzufügen

Beispiel:

sudo /etc/init.d/apache2 restart

Module/Erweiterungen

Der Apache Server lässt sich über Module erweitern. Weiterführende Informationen sind im Artikel Apache/Module zu finden.[2]

MySQL

Was ist MySQL?

MySQL ist eine leistungsfähige Datenbank-Serveranwendung. Die Firma MySQL AB, welche hinter der Entwicklung der Datenbank steht, wurde im Jahr 2008 von Sun übernommen und ist seit der Übernahme von Sun durch Oracle nun dieser Firma zugehörig.

MySQL erfreut sich in der (Linux-)Community einer sehr großen Beliebtheit und wird sehr häufig für Webanwendungen zusammen mit dem Webserver Apache und PHP eingesetzt. Viele Projekte und Software wie z.B. OpenStreetMap oder TYPO3 verwenden MySQL als Datenbank. Auch Inyoka, die Software von ubuntuusers.de, auf der auch dieses Wiki läuft, setzt eine MySQL-Datenbank zur Speicherung der Daten ein.

Die MySQL-Datenbank gibt es in einer freien Community-Variante (welche über die Ubuntu-Quellen verfügbar ist) und einer kostenpflichtigen Enterprise-Variante. Von der Leistungsfähigkeit unterscheiden sich die beiden Varianten nur marginal, der Hauptunterschied liegt in der Geschwindigkeit und Häufigkeit, mit der Updates und Service-Packs angeboten werden, sowie in der Verfügbarkeit von kommerziellem Support. MySQL ist neben Linux auch für Windows, MacOS, FreeBSD, Solaris und weitere Betriebssysteme verfügbar. Als Alternative gibt es MariaDB.

Installation

MySQL-Server

MySQL kann direkt aus den Paketquellen von Ubuntu installiert werden. Dazu muss nur das Paket

  • mysql-server

Paketliste zum Kopieren: apt-get aptitude

sudo apt-get install mysql-server

aus der Paketverwaltung heraus installiert [1] werden. Unter Ubuntu 12.04 wird dabei Version 5.5 installiert.

PHP

Wer eine datenbankbasierte Webanwendung mit PHP 5 und MySQL aufsetzen möchte (z.B. ein CMS oder eine Bildergalerie), benötigt noch das Paket:

  • php5-mysql

Paketliste zum Kopieren: apt-get aptitude

sudo apt-get install php5-mysql

Konfiguration

MySQL wird über die Datei /etc/mysql/my.cnf konfiguriert (seit 15.04 lautet die relevante Datei /etc/mysql/mysql.conf.d/mysqld.cnf). Es müssen üblicherweise aber keine Änderungen vorgenommen werden. Mittels eines Editors kann man Funktionen aktivieren bzw. Einstellungen vornehmen. Die wichtigsten Optionen sollen hier kurz vorgestellt werden.

Datenpfad

MySQL speichert die Datenbanken im Verzeichnis /var/lib/mysql ab. Möchte man einen anderen Pfad definieren, so kann man dies über die Option

datadir = /var/lib/mysql

eintragen. Dabei ist zu beachten, dass das Verzeichnis dem Benutzer bzw. der Gruppe mysql gehören sollten, damit der MySQL-Server dort auch schreiben darf. Mehr zum Thema Benutzer und Gruppen im Artikel Benutzer und Gruppen.

Lässt sich der MySQL-Server danach nicht mehr starten, liegt es wahrscheinlich an den Profil-Einstellungen von AppArmor. Wird das Datenbankverzeichnis in der Konfigurationsdatei geändert, aber nicht im AppArmor-Profil angepasst, kann MySQL nicht mehr auf alle Datenbanken bzw. auf Teile von bestehenden Datenbanken zugreifen. Es wird dann z.B. folgender Fehler gemeldet:

mysqlshow

mysqlshow: Cannot list databases: Can’t read dir of ‚.‘ (errno: 13)

Oder wenn man auf der MySQL-Kommandozeile angemeldet ist:

show databases;

ERROR 1018 (HY000): Can’t read dir of ‚.‘ (errno: 13)

Dieser Fehler wirkt sich auch auf PHPmyAdmin aus. Dort wird im linken sowie im rechten Fenster immer nur „Keine Datenbanken“ angezeigt.

Abhilfe schafft die Anpassung des Ordners in der Datei /etc/apparmor.d/usr.sbin.mysqld:

1

2

3

4

/var/lib/mysql/ r,

/var/lib/mysql/** rwk,

und ein Neustart von AppArmor.

MySQL über das Netzwerk

Nach der Installation ist der MySQL-Server so konfiguriert, dass er nur via localhost – also vom lokalen Rechner aus – erreichbar ist. Soll der Server über das Netzwerk ansprechbar sein, so kann man in/etc/mysql/my.cnf die interne IP-Adresse des Servers eintragen:

1

2

3

# Instead of skip-networking the default is now to listen only on

# localhost which is more compatible and is not less secure.

bind-address = 192.168.0.10

So ist der MySQL-Server z.B. auch von anderen Rechnern aus dem LAN ansprechbar. Per Voreinstellung ist MySQL über den Port 3306 erreichbar. Dieser kann auch in der Konfigurationsdatei geändert werden.

Wenn von allen Netzwerk-Interfaces zugegriffen werden soll, so muss bind-address mit „bind-address = “ oder mit „bind-address = 0.0.0.0“ konfiguriert werden. Alternativ kann der bind-address Eintrag auch auskommentiert werden.

Weiterhin muss in den Benutzerrechten pro Benutzer hinterlegt werden, ob dieser sich über das Netzwerk anmelden darf. Weitere Hinweise hierzu findet man im MySQL Handbuch.

Bedienung

Hier wird nur ein kurzer Einblick in die Bedienung von MySQL gegeben. Eine sehr umfangreiche Dokumentation steht in Form des Referenzhandbuchs online zur Verfügung.

Benutzer

root

Bei der Installation des Servers wird automatisch ein root-Account angelegt. Dabei ist zu beachten, dass die Benutzerverwaltung von MySQL nichts mit den lokalen Benutzern des Linux-Systems zu tun hat – MySQL verwaltet seine Benutzer selber. Bei der Installation des MySQL-Servers wird automatisch nach einem Passwort für den Datenbank-Administrator root gefragt.

Mit dem Befehl

mysqladmin -u root -p password „WUNSCHPASSWORT“

kann das Passwort nachträglich geändert werde. Dabei wird nach dem bisherigen Passwort gefragt. Wenn noch keines hinterlegt ist, kann man hier einfach mit der Taste ⏎ bestätigen.

debian-sys-maint

Ubuntu legt noch einen weiteren Benutzer an: debian-sys-maint. Mit Hilfe dieses MySQL-Benutzers startet und stoppt Ubuntu den SQL-Server und führt weitere Wartungs-Aufgaben durch. Der Zugang ist Passwort-geschützt. Ubuntu vergibt ein voreingestelltes Passwort, das in der Datei /etc/mysql/debian.cnf im Klartext abgelegt wird. Für administrative Aufgaben kann man daher auch den Benutzer debian-sys-maint verwenden mit:

mysql -u debian-sys-maint -p

In /etc/mysql/debian.cnf befinden sich zwei identische Einträge für das Passwort: z. B. password = n4aSHUP04s1J32X5.

Passwort zurücksetzen/neu vergeben

Hat man das Passwort für den Benutzer root vergessen, kann man mit Hilfe des Benutzers debian-sys-maint das Passwort zurücksetzen und neu vergeben. Einfach wie oben beschrieben als Benutzerdebian-sys-maint am MySQL-Server anmelden und die folgende Befehlssequenz am MySQL-Prompt mysql> eingeben:

update mysql.user set Password=password(‚MyNewPass‘) where User=’root‘;

flush privileges;

quit;

Erscheint beim (Neu-)Start des MySQL-Servers folgende Fehlermeldung:

sudo service mysql restart

* Stopping MySQL database server mysqld [fail]

* Starting MySQL database server mysqld [ OK ]

/usr/bin/mysql-admin: connect to server at ‚localhost‘ failed

error: ‚Access denied for user ‚debian-sys-maint’@’localhost‘ (using password: YES)‘

muss man das Passwort für den Benutzer debian-sys-maint neu setzen. Dies kann der Fall sein, wenn Ubuntu während eines Upgrades des Pakets mysql-server das Passwort für debian-sys-maintüberschreibt. In diesem Fall als Benutzer root am SQL-Server anmelden und nachfolgende Befehlssequenz am MYSQL-Prompt mysql> eingeben. Dabei newpassword durch den Passwort-Eintrag in der Datei/etc/mysql/debian.cnf ersetzen.

grant all privileges on *.* to ‚debian-sys-maint’@’localhost‘ identified by ’newpassword‘ with grant option;

flush privileges;

quit;

Datenbank erstellen

Zum Erstellen einer neuen Datenbank meldet man sich zuerst als Datenbank-Administrator an:

mysql -u root -p

Am MySQL-Prompt mysql> werden folgende SQL-Befehle benötigt. Bei erfolgreicher Ausführung erhält man eine Rückmeldung in der Form:

Query OK, … rows affected (… sec)

  • Datenbank erstellen (in der Praxis entspricht der Datenbankname häufig dem der gewünschten Anwendung):

create database if not exists datenbankname;

  • Neuen Datenbank-Benutzer www-data mit dem Kennwort geheim erstellen (wenn die Datenbank im Rahmen eines LAMP-Servers eingesetzt werden soll):

create user ‚www-data’@’localhost‘ identified by ‚geheim‘;

grant usage on *.* to ‚www-data’@’localhost‘ identified by ‚geheim‘;

  • Zugriffe auf die neue Datenbank für den Benutzer www-data erlauben:

grant all privileges on datenbankname.* to ‚www-data’@’localhost‘;

flush privileges;

  • Abmelden mit:

quit;

Alternativ kann exit; benutzt werden.

Tabellenarten

MySQL kennt verschiedene Tabellenarten, die sogenannten Storage Engines. Diese haben jeweils spezifische Vor- und Nachteile. Die Art der Tabelle kann beim Anlegen über die Option ENGINE= festgelegt werden. Innerhalb einer Datenbank können verschiedene Tabellen gemischt werden.

MyISAM-Tabellen

MyISAM ist die Standardtabellenart von MySQL und – sofern nicht explizit anders angegeben – per Voreinstellung genutzt. MyISAM-Tabellen haben grundsätzlich keine Größenbeschränkung und gelten besonders bei häufigen SELECT- und INSERT-Operationen als sehr effizient und schnell. Allerdings sind MyISAM-Tabellen nicht transaktionssicher und unterstützen keine Fremdschlüssel (sogenannte „Constraints“).

InnoDB

Im Gegensatz zu den MyISAM-Tabellen sind InnoDB-Tabellen transaktionssicher und unterstützen Fremdschlüssel. Ist die Datenkonsistenz sehr wichtig, so wird in der Regel InnoDB als Engine eingesetzt.

Weitere Tabellenarten

Wie oben bereits erwähnt, unterstützt MySQL noch eine Anzahl weitere Tabellenarten, wobei MyISAM und InnoDB sicherlich die am häufigsten eingesetzten sind. Erwähnenswert sind noch Tabellen auf Basis der „Memory-Engine“. Diese werden komplett im RAM des Servers gehalten und sind dadurch natürlich entsprechend schnell. Memory-Tabellen werden bevorzugt für temporäre Tabellen eingesetzt oder für Tabellenkopien mit häufigen Zugriffen, auf die nur lesend zugegriffen wird.

MySQL-Server steuern

Wie alle anderen Dienste bringt MySQL-Start/Stop-Skripte mit. Diese Skripte lassen sich natürlich auch zum Kontrollieren des Servers gebrauchen. Aus einem Terminal [2] heraus kann man mit

sudo service mysql {start|stop|restart|reload|force-reload|status}

Beispiel:

sudo service mysql reload

den Server steuern. Die einzelnen Optionen dabei bedeuten:

  • start – Startet den MySQL-Server
  • stop – Stoppt den Server
  • restart – Startet den Server neu, bestehende Verbindungen auf den Server werden gekappt
  • reload – Lädt die Konfigurationsdateien neu, ohne dass Verbindungen getrennt werden
  • force-reload – Lädt die Konfigurationsdateien neu, auch wenn dabei Verbindungen verloren gehen
  • status – Zeigt Status-Informationen und den Zustand des MySQL-Servers an

Achtung!

Für die einwandfreie Funktion von MySQL ist es entscheidend, dass der Daemon stets korrekt heruntergefahren und nicht bspw. bei einem Neustart des Systems abgeschossen wird. Wenn man ihn nur gelegentlich zu Entwicklerzwecken braucht, sollte man deshalb am besten nicht – wie in Dienste beschrieben – mit dem Kommando update-rc.d alle Start- und Stop-Links aus den Runleveln entfernen, sondern nur den Startlink aus dem Runlevel 2:

sudo rm /etc/rc2.d/S20mysql

Dadurch wird der Dienst beim Shutdown immer korrekt heruntergefahren, auch wenn man vergessen hat, dass er noch läuft. Eine Raute # vor dem Eintrag start on in /etc/init/mysql.conf verhindert den automatischen Start:

1 #start on …

Datensicherung

Hat man kritische, und/oder sensible, Daten in der Datenbank, ist es – wie üblich – ratsam, regelmäßig ein Backup der Daten zu machen. Dazu gibt es unterschiedliche Möglichkeiten wie etwa die direkte Kopie der Daten, das Auslesen der Datenbanken und Speichern des Inhalts aber auch den Aufbau von Redundanzen (Replikation). Details zum Thema sind im Artikel MySQL/Backup näher beschrieben.

Graphische Oberflächen

Es gibt eine Reihe von graphischen Benutzeroberflächen, die den Umgang mit MySQL erleichtern. Mehr Informationen findet man im Artikel MySQL/Werkzeuge.[3]

nginx

Introduction

The LEMP software stack is a group of software that can be used to serve dynamic web pages and web applications. This is an acronym that describes a Linux operating system, with an Nginx web server. The backend data is stored in MySQL and the dynamic processing is handled by PHP.

In this guide, we will demonstrate how to install a LEMP stack on an Ubuntu 14.04 server. The Ubuntu operating system takes care of the first requirement. We will describe how to get the rest of the components up and running.

Note: The LEMP Stack can be installed automatically on your Droplet by adding this script to its User Data when launching it. Check out this tutorial to learn more about Droplet User Data.

Prerequisites

Before you complete this tutorial, you should have a regular, non-root user account on your server withsudo privileges. You can learn how to set up this type of account by completing steps 1-4 in our Ubuntu 14.04 initial server setup.

Once you have your account available, sign into your server with that username. You are now ready to begin the steps outlined in this guide.

Step One — Install the Nginx Web Server

In order to display web pages to our site visitors, we are going to employ Nginx, a modern, efficient web server.

All of the software we will be getting for this procedure will come directly from Ubuntu’s default package repositories. This means we can use the apt package management suite to complete the installation.

Since this is our first time using apt for this session, we should start off by updating our local package index. We can then install the server:

sudo apt-get update

sudo apt-get install nginx

In Ubuntu 14.04, Nginx is configured to start running upon installation.

You can test if the server is up and running by accessing your server’s domain name or public IP address in your web browser.

If you do not have a domain name pointed at your server and you do not know your server’s public IP address, you can find it by typing one of the following into your terminal:

ip addr show eth0 | grep inet | awk ‚{ print $2; }‘ | sed ’s/\/.*$//‘

111.111.111.111

fe80::601:17ff:fe61:9801

Or you could try using:

curl http://icanhazip.com

111.111.111.111

Try one of the lines that you receive in your web browser. It should take you to Nginx’s default landing page:

http://server_domain_name_or_IP

Nginx default page

If you see the above page, you have successfully installed Nginx.

Step Two — Install MySQL to Manage Site Data

Now that we have a web server, we need to install MySQL, a database management system, to store and manage the data for our site.

You can install this easily by typing:

sudo apt-get install mysql-server

You will be asked to supply a root (administrative) password for use within the MySQL system.

The MySQL database software is now installed, but its configuration is not exactly complete yet.

First, we need to tell MySQL to generate the directory structure it needs to store its databases and information. We can do this by typing:

sudo mysql_install_db

Next, you’ll want to run a simple security script that will prompt you to modify some insecure defaults. Begin the script by typing:

sudo mysql_secure_installation

You will need to enter the MySQL root password that you selected during installation.

Next, it will ask if you want to change that password. If you are happy with your MySQL root password, type „N“ for no and hit „ENTER“. Afterwards, you will be prompted to remove some test users and databases. You should just hit „ENTER“ through these prompts to remove the unsafe default settings.

Once the script has been run, MySQL is ready to go.

Step Three — Install PHP for Processing

Now we have Nginx installed to serve our pages and MySQL installed to store and manage our data, but we still need something to connect these two pieces and to generate dynamic content. We can use PHP for this.

Since Nginx does not contain native PHP processing like some other web servers, we will need to installphp5-fpm, which stands for „fastCGI process manager“. We will tell Nginx to pass PHP requests to this software for processing.

We can install this module and will also grab an additional helper package that will allow PHP to communicate with our database backend. The installation will pull in the necessary PHP core files. Do this by typing:

sudo apt-get install php5-fpm php5-mysql

Configure the PHP Processor

We now have our PHP components installed, but we need to make a slight configuration change to make our setup more secure.

Open the main php5-fpm configuration file with root privileges:

sudo nano /etc/php5/fpm/php.ini

What we are looking for in this file is the parameter that sets cgi.fix_pathinfo. This will be commented out with a semi-colon (;) and set to „1“ by default.

This is an extremely insecure setting because it tells PHP to attempt to execute the closest file it can find if a PHP file does not match exactly. This basically would allow users to craft PHP requests in a way that would allow them to execute scripts that they shouldn’t be allowed to execute.

We will change both of these conditions by uncommenting the line and setting it to „0“ like this:

cgi.fix_pathinfo=0

Save and close the file when you are finished.

Now, we just need to restart our PHP processor by typing:

sudo service php5-fpm restart

This will implement the change that we made.

Step Four — Configure Nginx to Use our PHP Processor

Now, we have all of the required components installed. The only configuration change we still need to do is tell Nginx to use our PHP processor for dynamic content.

We do this on the server block level (server blocks are similar to Apache’s virtual hosts). Open the default Nginx server block configuration file by typing:

sudo nano /etc/nginx/sites-available/default

Currently, with the comments removed, the Nginx default server block file looks like this:

server {

listen 80 default_server;

listen [::]:80 default_server ipv6only=on;

root /usr/share/nginx/html;

index index.html index.htm;

server_name localhost;

location / {

try_files $uri $uri/ =404;

}

}

We need to make some changes to this file for our site.

  • First, we need to add an index.php option as the first value of our index directive to allow PHP index files to be served when a directory is requested.
  • We also need to modify the server_name directive to point to our server’s domain name or public IP address.
  • The actual configuration file includes some commented out lines that define error processing routines. We will uncomment those to include that functionality.
  • For the actual PHP processing, we will need to uncomment a portion of another section. We will also need to add a try_files directive to make sure Nginx doesn’t pass bad requests to our PHP processor.

The changes that you need to make are in red in the text below:

server {

listen 80 default_server;

listen [::]:80 default_server ipv6only=on;

root /usr/share/nginx/html;

index index.php index.html index.htm;

server_name server_domain_name_or_IP;

location / {

try_files $uri $uri/ =404;

}

error_page 404 /404.html;

error_page 500 502 503 504 /50x.html;

location = /50x.html {

root /usr/share/nginx/html;

}

location ~ \.php$ {

try_files $uri =404;

fastcgi_split_path_info ^(.+\.php)(/.+)$;

fastcgi_pass unix:/var/run/php5-fpm.sock;

fastcgi_index index.php;

fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

include fastcgi_params;

}

}

When you’ve made the above changes, you can save and close the file.

Restart Nginx to make the necessary changes:

sudo service nginx restart

Step Five — Create a PHP File to Test Configuration

Your LEMP stack should now be completely set up. We still should test to make sure that Nginx can correctly hand .php files off to our PHP processor.

We can do this by creating a test PHP file in our document root. Open a new file called info.php within your document root in your text editor:

sudo nano /usr/share/nginx/html/info.php

We can type this into the new file. This is valid PHP code that will return formatted information about our server:

<?php

phpinfo();

?>

When you are finished, save and close the file.

Now, you can visit this page in your web browser by visiting your server’s domain name or public IP address followed by /info.php:

http://server_domain_name_or_IP/info.php

You should see a web page that has been generated by PHP with information about your server:

PHP page info If you see a page that looks like this, you’ve set up PHP processing with Nginx successfully.

After you test this, it’s probably best to remove the file you created as it can actually give unauthorized users some hints about your configuration that may help them try to break in. You can always regenerate this file if you need it later.

For now, remove the file by typing:

sudo rm /usr/share/nginx/html/info.php

[4]

phpMyAdmin for nginx

Introduction

Relational database management systems like MySQL are needed for a significant portion of web sites and applications. However, not all users feel comfortable administering their data from the command line.

To solve this problem, a project called phpMyAdmin was created in order to offer an alternative in the form of a web-based management interface. In this guide, we will demonstrate how to install and secure a phpMyAdmin configuration on an Ubuntu 14.04 server. We will build this setup on top of the Nginx web server, which has a good performance profile and can handle heavy loads better than some other web servers.

Prerequisites

Before we begin, there are a few requirements that need to be settled.

To ensure that you have a solid base to build this system upon, you should run through our initial server setup guide for Ubuntu 14.04. Among other things, this will walk you through setting up a non-root user with sudo access for administrative commands.

The second prerequisite that must be fulfilled in order to start on this guide is to install a LEMP (Linux, Nginx, MySQL, and PHP) stack on your Ubuntu 14.04 server. This is the platform that we will use to serve our phpMyAdmin interface (MySQL is also the database management software that we are wishing to manage). If you do not yet have a LEMP installation on your server, follow our tutorial on installing LEMP on Ubuntu 14.04.

When your server is in a properly functioning state after following these guides, you can continue on with the rest of this page.

Step One — Install phpMyAdmin

With our LEMP platform already in place, we can begin right away with installing the phpMyAdmin software. This is available within Ubuntu’s default repositories, so the installation process is simple.

First, update the server’s local package index to make sure it has a fresh set of references to available packages. Then, we can use the apt packaging tools to pull the software down from the repositories and install it on our system:

sudo apt-get update

sudo apt-get install phpmyadmin

During the installation, you will be prompted for some information. It will ask you which web server you would like the software to automatically configure. Since Nginx, the web server we are using, is not one of the available options, you can just hit TAB to bypass this prompt.

The next prompt will ask if you would like dbconfig-common to configure a database for phpmyadmin to use. Select „Yes“ to continue.

You will need to enter the database administrative password that you configured during the MySQL installation to allow these changes. Afterward, you will be asked to select and confirm a password for a new database that will hold phpMyAdmin’s own data.

The installation will now complete. For the Nginx web server to find and serve the phpMyAdmin files correctly, we just need to create a symbolic link from the installation files to our Nginx document root directory by typing this:

sudo ln -s /usr/share/phpmyadmin /usr/share/nginx/html

A final item that we need to address is enabling the mcrypt PHP module, which phpMyAdmin relies on. This was installed with phpMyAdmin so we just need to toggle it on and restart our PHP processor:

sudo php5enmod mcrypt

sudo service php5-fpm restart

With that, our phpMyAdmin installation is now operational. To access the interface, go to your server’s domain name or public IP address followed by /phpmyadmin, in your web browser:

http://server_domain_or_IP/phpmyadmin

phpMyAdmin login screen

To sign in, use a username/password pair of a valid MySQL user. The root user and the MySQL administrative password is a good choice to get started. You will then be able to access the administrative interface:

phpMyAdmin admin interface

Click around to get familiar with the interface. In the next section, we will take steps to secure our new interface.

Step Two — Secure your phpMyAdmin Instance

The phpMyAdmin instance installed on our server should be completely usable at this point. However, by installing a web interface, we have exposed our MySQL system to the outside world.

Even with the included authentication screen, this is quite a problem. Because of phpMyAdmin’s popularity combined with the large amount of data it provides access to, installations like these are common targets for attackers.

We will implement two simple strategies to lessen the chances of our installation being targeted and compromised. We will change the location of the interface from /phpmyadmin to something else to sidestep some of the automated bot brute-force attempts. We will also create an additional, web server-level authentication gateway that must be passed before even getting to the phpMyAdmin login screen.

Changing the Application’s Access Location

In order for our Nginx web server to find and serve our phpMyAdmin files, we created a symbolic link from the phpMyAdmin directory to our document root in an earlier step.

To change the URL where our phpMyAdmin interface can be accessed, we simply need to rename the symbolic link. Move into the Nginx document root directory to get a better idea of what we are doing:

cd /usr/share/nginx/html

ls -l

total 8

-rw-r–r– 1 root root 537 Mar 4 06:46 50x.html

-rw-r–r– 1 root root 612 Mar 4 06:46 index.html

lrwxrwxrwx 1 root root 21 Aug 6 10:50 phpmyadmin -> /usr/share/phpmyadmin

As you can see, we have a symbolic link called phpmyadmin in this directory. We can change this link name to whatever we would like. This will change the location where phpMyAdmin can be accessed from a browser, which can help obscure the access point from hard-coded bots.

Choose a name that does not indicate the purpose of the location. In this guide, we will name our access location /nothingtosee. To accomplish this, we will just rename the link:

sudo mv phpmyadmin nothingtosee

ls -l

total 8

-rw-r–r– 1 root root 537 Mar 4 06:46 50x.html

-rw-r–r– 1 root root 612 Mar 4 06:46 index.html

lrwxrwxrwx 1 root root 21 Aug 6 10:50 nothingtosee -> /usr/share/phpmyadmin

Now, if you go to the previous location of your phpMyAdmin installation, you will get a 404 error:

http://server_domain_or_IP/phpmyadmin

phpMyAdmin 404 error

However, your phpMyAdmin interface will be available at the new location we selected:

http://server_domain_or_IP/nothingtosee

phpMyAdmin login screen

[5]

  1. Quelle: https://www.digitalocean.com/community/tutorials/how-to-set-up-an-nfs-mount-on-ubuntu-14-04
  2. Quelle: https://wiki.ubuntuusers.de/Apache/
  3. Quelle: https://wiki.ubuntuusers.de/MySQL/
  4. Quelle: https://www.digitalocean.com/community/tutorials/how-to-install-linux-nginx-mysql-php-lemp-stack-on-ubuntu-14-04
  5. Quelle: https://www.digitalocean.com/community/tutorials/how-to-install-and-secure-phpmyadmin-with-nginx-on-an-ubuntu-14-04-server

Learning management system for IT

error: Content is protected !!
Zur Werkzeugleiste springen