Les 0: basisconfiguratie Ubuntu-server
We gaan een Ubuntu 20.04 server maken en wat basis instellingen en configuraties toepassen. Belangrijk is van elke stap een "Snapshot" te maken, zodat je deze server meerdere malen kunt gebruiken.
VM maken Ubuntu 20.04 server
Download Ubuntu server van de officiële website en installeer dit in een virtuele machine.
https://ubuntu.com/download/server
Kies voor "option 2" hier kan je het iso bestand downloaden.
Basisconfiguratie
Wanneer je voor het eerst een nieuwe Ubuntu 20.04-server maakt, moet je enkele belangrijke configuratiestappen uitvoeren als onderdeel van de basisinstallatie. Deze stappen zullen de veiligheid en bruikbaarheid van je server verhogen, en zal je een solide basis geven voor vervolgacties.
Stap 1. Aanmaken gebruiker met sudo rechten
Tenzij je eigen gebruiker in de sudo groep zit moet je een nieuwe gebruiker aanmaken. Eerst gaan we controleren of onze eigen gebruiken in de sudo groep zit en hierdoor opdrachten mag uitvoeren met root rechten.
cat /etc/group | grep sudo
Je zult zien dat je gebruiker die je hebt aangemaakt tijdens de installatie in de sudo groep zit en root rechten heeft voor het uitvoeren van opdrachten.
We gaan een test gebruiker aanmaken om er zeker van te zijn dat iedereen voor aanvang minimaal 1 gebruiker heeft met root rechten.
Zodra je bent aangemeld, zijn we gereed om het nieuwe gebruikersaccount toe te voegen. In de toekomst zullen we inloggen met dit nieuwe account in plaats van met onze eigen gebruiker.
In dit voorbeeld wordt een nieuwe gebruiker gemaakt met de naam student, maar je kunt deze vervangen door een gebruikersnaam die je bevalt:
sudo adduser student
Er worden een paar vragen gesteld, te beginnen met het accountwachtwoord.
Voer een sterk wachtwoord in en vul desgewenst aanvullende informatie in. Dit is niet vereist en je kunt gewoon ENTERin elk veld klikken dat je wil overslaan.
Nu hebben we een nieuw gebruikersaccount met normale accountrechten. Soms moeten we echter administratieve taken uitvoeren. Deze gebruiker moet dan ook in de sudo groep komen.
sudo usermod -aG sudo student
Controleren of student in de sudo groep zit.
Stap 2. Basis firewall instellingen
Ubuntu 20.04-servers kunnen de UFW-firewall gebruiken om ervoor te zorgen dat alleen verbindingen met bepaalde services zijn toegestaan. Met deze applicatie kunnen we heel eenvoudig een standaard firewall opzetten.
Toepassingen kunnen hun profielen na installatie registreren bij UFW. Met deze profielen kan UFW deze applicaties op naam beheren.
sudo ufw app list
Als het goed is staat OpenSSH als enige applicatie in de lijst. Zoniet, dan moet je OpenSSH installeren, want die gaan we nodig zijn om verbinding naar de server te krijgen.
We moeten ervoor zorgen dat de firewall SSH-verbindingen toestaat, zodat we de volgende keer weer kunnen inloggen. We kunnen deze verbindingen toestaan door te typen:
sudo ufw allow OpenSSH
Daarna kunnen we de firewall inschakelen door te typen:
sudo ufw enable
Typ yen druk op ENTERom door te gaan. U kunt zien dat SSH-verbindingen nog steeds zijn toegestaan door te typen:
sudo ufw status
ufw configuratie
Stap 3. SSH toegang voor je "gewone" gebruiker
Nu we een gebruiker hebben voor dagelijks gebruik, moeten we ervoor zorgen dat we rechtstreeks naar het account kunnenmet SSH.
Eerst moeten we weten wat ons IP adres is van de server. Hiervoor kun je 2 opdrachten gebruiken.
ip a
hostname -I
Je kunt nu een SSH sessie opbouwen vanaf je Ubuntu Desktop. Hiervoor gebruik je de volgende opdracht.
ssh student@192.168.182.130
Vervang het IP-adres door je eigen IP-adres!!!!!
Er wordt gevraagd of je zeker bent van het verbinden, type hier yes. Vul vervolgens het wachtwoord in van de gebruiker student en de SSH verbinding wordt opgezet.
Om de beveiliging van uw server te verbeteren, raden we u ten zeerste aan SSH-sleutels in te stellen in plaats van wachtwoordverificatie te gebruiken. Volg hiervoor het volgende tabblat.
SSH-keys
Stap 1. Maken van een SSH sleutelpaar
De eerste stap is het maken van een sleutelpaar op de cliëntcomputer (de computer waarmee je de ssh verbinding wil gaan maken)
ssh-keygen
Standaard zullen recente versies van ssh-keygeneen 3072-bits RSA-sleutelpaar (Windows 2048-bits) maken, dat voldoende veilig is voor de meeste gevallen (je kunt optioneel de -b 4096vlag doorgeven om een grotere 4096-bits sleutel te maken).
ssh-keygen
Wanneer je gebruik maakt van Windows als OS om grotere keys te genereren ga je als volgt te werk: ssh-keygen -t rsa 4096
ssh keygen Windows 10
Als je ervoor kiest om de sleutel op schijf te overschrijven, kun je niet meer verifiëren met de vorige sleutel. Wees heel voorzichtig bij het selecteren van ja, aangezien dit een destructief proces is dat niet ongedaan kan worden gemaakt.
Aangezien dit waarschijnlijk de eerste keer is dat je sleutels aanmaakt kies voory
Hier kun je optioneel een veilige wachtwoordzin invoeren, wat sterk wordt aanbevolen. Een wachtwoordzin voegt een extra beveiligingslaag toe om te voorkomen dat onbevoegde gebruikers inloggen. Aangezien dit een testomgeving is gaan wij dit met enter doorheen.
Hierna zal er een output komen dat je sleutelpaar is aangemaakt.
Stap 2. Kopiëren van de openbare sleutel naar je Ubuntu-server
De snelste manier om uw openbare sleutel naar de Ubuntu-host te kopiëren, is door een hulpprogramma met de naam ssh-copy-id. Vanwege zijn eenvoud wordt deze methode ten zeerste aanbevolen, indien beschikbaar.
De ssh-copy-idtool is standaard opgenomen in veel besturingssystemen, dus het kan zijn dat je hem beschikbaar hebt op je lokale systeem. Om deze methode te laten werken, moet u al op een wachtwoord gebaseerde SSH-toegang tot uw server hebben.
Om het hulpprogramma te gebruiken, specificeert u de externe host waarmee u verbinding wilt maken, en het gebruikersaccount waartoe u op wachtwoord gebaseerde SSH-toegang hebt. Dit is het account waarnaar uw openbare SSH-sleutel wordt gekopieerd.
De syntaxis is:
ssh-copy-id username@remote_host
Goed kijken welk wachtwoord je in moet vullen, eerste voor de gebruiker student. Als je op de sleutel een wachtwoord hebt gezet, dan moet je die daarna invoeren.
Mogelijk ziet u het volgende bericht:
ssh-copy-id
Het kopieren van de ssh-key welke je net gemaakt hebt met Windows gaat net iets anders. Hiervoor gebruik je Windows Powershell. Hiervoor gebruik je het volgende commando: type C:\Users\[user]\.ssh\id_rsa.pub | ssh [user]@[host ip]'cat >> .ssh/authorized_keys'
vervang [user] voor de gebruiker waardoor de key is gegenereerd
Vervang [user@ host ip voor de gegevens waarmee je inlogt eg. martijn@192.168.75.137]
Stap 3. SSH verbinding maken
Maak opnieuw verbinding met de gebruiker student om te zien dat er nu zonder wachtwoord verificatie wordt ingelogd.
De sleutel is naar de home directory van de gebruiker student gekopieërd. Deze staat in ~/.ssh/authorized_keys.
Stap 4. Wachtwoordverificatie uitzetten op je Ubuntu-server
Als je in staat was om in te loggen op je account met SSH zonder wachtwoord, heb je met succes SSH-key-gebaseerde authenticatie geconfigureerd voor je account. Uw wachtwoordgebaseerde authenticatiemechanisme is echter nog steeds actief, wat betekent dat uw server nog steeds wordt blootgesteld aan brute-force-aanvallen.
Zodra u heeft bevestigd dat uw externe account beheerdersrechten heeft, logt u in op uw externe server met SSH-sleutels. Kan je gebruiker sudo opdrachten uitvoeren? Dan kun je wachtwoordverificatie uitzetten in het configuratiebestand van SSH.
ervolgens het configuratiebestand van de SSH-daemon:
sudo nano /etc/ssh/sshd_config
Zoek in het bestand naar een richtlijn met de naam PasswordAuthentication. Deze regel kan worden becommentarieerd met een #aan het begin van de regel. Maak het commentaar op de regel ongedaan door de #, te verwijderen en de waarde in te stellen op no. Dit zal uw mogelijkheid om in te loggen via SSH met accountwachtwoorden uitschakelen.
Sla het bestand op en sluit het als u klaar bent door op te drukken CTRL+X, vervolgens Yom het opslaan van het bestand te bevestigen en ten slotte ENTERnano af te sluiten. Om deze wijzigingen daadwerkelijk te activeren, moeten we de sshdservice opnieuw starten :
sudo systemctl restart ssh
Open uit voorzorg een nieuw terminalvenster en test of de SSH-service correct werkt voordat u uw huidige sessie afsluit:
ssh username@remote_host
Zodra u heeft gecontroleerd of uw SSH-service correct werkt, kunt u alle huidige serversessies veilig sluiten.
Snapshot maken
Maak nu de snapshot. De basisconfiguratie voor de komende lessen is gereed en kunnen we voor elke individuele les gebruiken.
Voor elke les zul je terug moeten naar de basisconfiguratie met de zojuist ingestelde configuratie. Dan heb je voor elke les een schone server waar:
- SSH is ingesteld
- UFW SSH toestaat
- Gebuiker met ROOT en/of sudo rechten
Take a snapshot
Les 1: Apache
Deze les gaan we een webserver opzetten met Apache2. Volg onderstaande stappen en je zult dat het configureren van meerdere websites dan goed te doen is.
Log in op de Ubuntu-server vanaf je Ubuntu-desktop met SSH met de aangemaakte gebruiker.
Apache installeren
Apache is beschikbaar in de standaard softwarebronnen van Ubuntu, waardoor het mogelijk is om het te installeren met behulp van conventionele hulpprogramma's voor pakketbeheer.
Laten we beginnen met het bijwerken van de lokale pakketindex om de laatste upstream-wijzigingen weer te geven:
sudo apt update
Installeer vervolgens het apache2pakket:
sudo apt install apache2
Na bevestiging van de installatie, aptinstalleert Apache en alle vereiste afhankelijkheden.
UFW aanpassen
Voordat u Apache test, is het noodzakelijk om de firewall-instellingen te wijzigen om externe toegang tot de standaardwebpoorten toe te staan. Ervan uitgaande dat u de instructies in de vereisten hebt gevolgd, zou u een UFW-firewall moeten hebben geconfigureerd om de toegang tot uw server te beperken.
Maak een lijst van de ufwapplicatieprofielen door te typen:
sudo ufw app list
U ontvangt een lijst met de toepassingsprofielen:
Zoals aangegeven door de uitvoer, zijn er drie profielen beschikbaar voor Apache:
- Apache : dit profiel opent alleen poort 80 (normaal, niet-versleuteld webverkeer)
- Apache Full : dit profiel opent zowel poort 80 (normaal, niet-versleuteld webverkeer) als poort 443 (TLS / SSL-versleuteld verkeer)
- Apache Secure : dit profiel opent alleen poort 443 (TLS / SSL versleuteld verkeer)
Het wordt aanbevolen om het meest beperkende profiel in te schakelen dat nog steeds het door u geconfigureerde verkeer toelaat. Aangezien we in deze handleiding nog geen SSL voor onze server hebben geconfigureerd, hoeven we alleen verkeer op poort 80 toe te staan:
sudo ufw allow Apache
U kunt de wijziging verifiëren door te typen:
sudo ufw status
De uitvoer geeft een lijst met toegestaan HTTP-verkeer:
De webserver controleren
Aan het einde van het installatieproces start Ubuntu 20.04 Apache. De webserver zou al actief moeten zijn.
Neem contact op met het systemdinit-systeem om er zeker van te zijn dat de service actief is door te typen:
sudo systemctl status apache2
Zoals bevestigd door deze uitvoer, is de service met succes gestart. De beste manier om dit te testen, is door een pagina op te vragen bij Apache.
Hiervoor heb je het IP-adres nodig van je server (zelfde als de SSH verbinding).
hostname -I
Dit IP-adres vul je in als URL in Firefox en je krijgt de Default-landing-page van Apache.
Default landing page Apache
Beheren van Apache processen
Nu uw webserver actief is, gaan we enkele basisbeheeropdrachten doornemen met systemctl.
Om uw webserver te stoppen, typt u:
sudo systemctl stop apache2
Om de webserver te starten wanneer deze is gestopt, typt u:
sudo systemctl start apache2
Om de service te stoppen en opnieuw te starten, typt u:
sudo systemctl restart apache2
Als u eenvoudig configuratiewijzigingen aanbrengt, kan Apache vaak opnieuw laden zonder verbindingen te verbreken. Gebruik hiervoor deze opdracht:
sudo systemctl reload apache2
Apache is standaard geconfigureerd om automatisch te starten wanneer de server opstart. Als dit niet is wat u wilt, schakelt u dit gedrag uit door te typen:
sudo systemctl disable apache2
Om de service opnieuw in te schakelen om bij het opstarten te starten, typ je:
sudo systemctl enable apache2
Apache zou nu automatisch moeten starten wanneer de server opnieuw opstart.
Virtuele host instellen
Apache op Ubuntu 20.04 heeft standaard één serverblok ingeschakeld dat is geconfigureerd om documenten uit de /var/www/htmlmap te serveren. Hoewel dit goed werkt voor een enkele site, kan het onpraktisch worden als u meerdere sites host. In plaats van te wijzigen /var/www/html, maken we een directorystructuur binnen /var/wwwvoor een site met uw_domein, en laten we deze /var/www/htmlop zijn plaats als de standaarddirectory die wordt bediend als een verzoek van een klant niet overeenkomt met andere sites.
Maak de map voor uw_domein als volgt:
sudo mkdir /var/www/your_domain
Wijs vervolgens het eigendom van de directory toe met de $USERomgevingsvariabele:
sudo chown -R $USER:$USER /var/www/your_domain
Maak vervolgens een voorbeeldpagina index.htmlmet nanoof uw favoriete editor:
sudo nano /var/www/your_domain/index.html
Voeg binnen de volgende voorbeeld-HTML toe:
Om Apache deze inhoud te laten leveren, is het nodig om een virtueel hostbestand met de juiste richtlijnen te maken. In plaats van het standaard configuratiebestand te wijzigen dat zich /etc/apache2/sites-available/000-default.confdirect op bevindt, laten we een nieuw bestand maken op:/etc/apache2/sites-available/your_domain.conf
sudo nano /etc/apache2/sites-available/your_domain.conf
Maak het volgende configuratieblok, dat vergelijkbaar is met het standaard, maar bijgewerkt voor onze nieuwe directory en domeinnaam:
<VirtualHost *:80>
ServerAdmin webmaster@localhost
ServerName noorderpoort
ServerAlias www.noorderpoort
DocumentRoot /var/www/noorderpoort
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
Merk op dat we het hebben bijgewerkt DocumentRootnaar onze nieuwe directory en ServerAdminnaar een e-mail waartoe de sitebeheerder van uw_domein toegang heeft. We hebben ook twee richtlijnen toegevoegd: ServerNamedie het basisdomein bepalen dat moet overeenkomen met deze virtuele hostdefinitie, en ServerAlias, die andere namen definieert die moeten overeenkomen alsof ze de basisnaam zijn.
Sla het bestand op en sluit het als u klaar bent.
Laten we het bestand inschakelen met de a2ensitetool:
sudo a2ensite your_domain.conf
Schakel de standaardsite uit die is gedefinieerd in 000-default.conf:
sudo a2dissite 000-default.conf
Laten we vervolgens testen op configuratiefouten:
sudo apache2ctl configtest
U zou de volgende uitvoer moeten ontvangen:
Output
Syntax OK
Start Apache opnieuw om uw wijzigingen door te voeren:
sudo systemctl restart apache2
Apache zou nu uw domeinnaam moeten bedienen. U kunt dit testen door te navigeren naar, waar u zoiets als dit zou moeten zien:http://IP_van_je_server
Apache bestanden en mappen
Inhoud
/var/www/html: De daadwerkelijke webinhoud, die standaard alleen bestaat uit de standaard Apache-pagina die u eerder zag, wordt uit de /var/www/htmldirectory geserveerd. Dit kan worden gewijzigd door Apache-configuratiebestanden te wijzigen.
Serverconfiguratie
/etc/apache2: De Apache-configuratiemap. Alle Apache-configuratiebestanden bevinden zich hier./etc/apache2/apache2.conf: Het belangrijkste Apache-configuratiebestand. Dit kan worden gewijzigd om wijzigingen aan te brengen in de algemene Apache-configuratie. Dit bestand is verantwoordelijk voor het laden van veel van de andere bestanden in de configuratiemap./etc/apache2/ports.conf: Dit bestand specificeert de poorten waarop Apache zal luisteren. Apache luistert standaard op poort 80 en luistert bovendien op poort 443 wanneer een module die SSL-mogelijkheden biedt, is ingeschakeld./etc/apache2/sites-available/: De map waar virtuele hosts per site kunnen worden opgeslagen. Apache zal de configuratiebestanden in deze map niet gebruiken, tenzij ze aan de sites-enabledmap zijn gekoppeld. Gewoonlijk wordt alle serverblokconfiguratie in deze directory uitgevoerd en vervolgens ingeschakeld door met de a2ensiteopdracht naar de andere directory te linken./etc/apache2/sites-enabled/: De map waar ingeschakelde virtuele hosts per site worden opgeslagen. Deze worden doorgaans gemaakt door te linken naar configuratiebestanden in de sites-availabledirectory met de a2ensite. Apache leest de configuratiebestanden en koppelingen in deze map wanneer het start of laadt opnieuw om een volledige configuratie te compileren./etc/apache2/conf-available/, /etc/apache2/conf-enabled/: Deze mappen hebben dezelfde relatie als sites-availableen sites-enableddirectories, maar worden gebruikt om configuratie fragmenten die niet behoren bij een virtuele host slaan. Bestanden in de conf-availabledirectory kunnen worden ingeschakeld met het a2enconfcommando en uitgeschakeld met het a2disconfcommando./etc/apache2/mods-available/, /etc/apache2/mods-enabled/: Deze mappen bevatten respectievelijk de beschikbare en ingeschakelde modules. Bestanden die eindigen op .loadbevatten fragmenten om specifieke modules te laden, terwijl bestanden die eindigen op .confde configuratie voor die modules bevatten. Modules kan worden in- en uitgeschakeld met behulp van de a2enmoden a2dismodcommando.
Serverlogboeken
/var/log/apache2/access.log: Standaard wordt elk verzoek aan uw webserver geregistreerd in dit logbestand, tenzij Apache is geconfigureerd om iets anders te doen./var/log/apache2/error.log: Standaard worden alle fouten in dit bestand vastgelegd. De LogLevelinstructie in de Apache-configuratie specificeert hoeveel details de foutenlogboeken zullen bevatten.
Snapshot maken
Als de apache configuratie is gelukt, dan hier een snapshot van maken.
Opdracht Apache webserver
De opdracht voor Apache staat op ItsLearning. Deze opdracht volledig maken en zorg voor voldoende screen-shots om aan te tonen dat de configuratie is gelukt.
Uitdaging: Apache
Als de Apache2 server gemakkelijk ging is hier een uitdaging. Probeer de uitrol van de server te automatiseren met Ansible.
Ansible is een opdracht gestuurde tool dat het uitrollen van configuraties makkelijk maakt, controleert en feedback geeft over de onderdelen dat niet goed is gegaan. Of Ansible nu 1 of 100 servers moet configureren, als je de IP-adressen hebt opgegeven kan je je configuraties remote uitrollen. Vanaf een desktop kun je nu je configuraties uitrollen, aanpassen en tweaken.
Ansible installeren
Configuratiebeheersystemen zijn ontworpen om het proces van het beheren van grote aantallen servers te stroomlijnen voor beheerders en operationele teams. Ze stellen je in staat om veel verschillende systemen op een geautomatiseerde manier vanaf één centrale locatie aan te sturen.
Hoewel er veel populaire hulpprogramma's voor configuratiebeheer beschikbaar zijn voor Linux-systemen, zoals Chef en Puppet, zijn deze vaak complexer dan veel mensen willen of nodig hebben. Ansible is een geweldig alternatief voor deze opties omdat het een architectuur biedt waarvoor geen speciale software op knooppunten hoeft te worden geïnstalleerd, waarbij SSH wordt gebruikt om de automatiseringstaken uit te voeren en YAML-bestanden om inrichtingsdetails te definiëren.
Omdat wij onze SSH-sleutel met de server hebben gedeelt hoeven we hier niks meer mee te doen. Mocht je dat niet hebben gedaan, zorg dan dat er 1 gebruiken met SSH-sleutels kan inloggen op de server. Deze gebruiker moeten we dadelijk aangeven in de configuratie.
Een Ansible host: We gaan ervan uit dat je een Ubuntu-desktop gebruikt als Ansible host, dit kan ook een server zijn of een andere Linux desktop.
Stap 1 - Ansible installeren
Om Ansible te gebruiken als een manier om je serverinfrastructuur te beheren, moet je de Ansible-software installeren op de machine die zal dienen als het Ansible-controleknooppunt. Daarvoor gebruiken we de standaard Ubuntu-repositories.
Vernieuw eerst de pakketindex van je systeem met:
sudo apt update
Na deze update kun je de Ansible-software installeren met:
sudo apt install ansible
Druk op Yals daarom wordt gevraagd om de installatie te bevestigen.
Je Ansible-controleknooppunt heeft nu alle benodigde software om je hosts te beheren. Vervolgens kijken we hoe je een inventarisbestand instelt, zodat Ansible kan communiceren met je beheerde knooppunten.
Ansible inventarisbestand
Het inventarisbestand bevat informatie over de hosts die je met Ansible beheert. Je kunt overal van één tot enkele honderden servers in je inventarisbestand opnemen, en hosts kunnen in groepen en subgroepen worden georganiseerd. Het inventarisbestand wordt ook vaak gebruikt om variabelen in te stellen die alleen geldig zijn voor specifieke hosts of groepen, om te worden gebruikt in playbooks en sjablonen. Sommige variabelen kunnen ook van invloed zijn op de manier waarop een playbook wordt uitgevoerd, zoals de ansible_python_interpretervariabele die we zo dadelijk zullen zien.
Om de inhoud van je standaard Ansible-inventaris te bewerken, open jehet /etc/ansible/hostsbestand met je gewenste teksteditor op je Ansible-controleknooppunt:
sudo nano /etc/ansible/hosts
Opmerking : hoewel Ansible doorgaans een standaardinventarisbestand aanmaakt op etc/ansible/hosts, staat het je vrij om inventarisbestanden te maken op elke locatie die beter aan je behoeften voldoet. In dit geval moet je het pad naar je aangepaste inventarisbestand opgeven met de -iparameter wanneer je Ansible-opdrachten en playbooks uitvoert. Het gebruik van inventarisbestanden per project is een goede gewoonte om het risico van het draaien van een playbook op de verkeerde groep servers te minimaliseren.
Het standaard inventarisbestand dat wordt geleverd door de Ansible-installatie bevat een aantal voorbeelden die je kunt gebruiken als referentie voor het opzetten van je inventaris. In het volgende voorbeeld wordt een groep gedefinieerd [servers]met drie verschillende servers erin, elk geïdentificeerd door een aangepaste alias: server1 , server2 en server3 . Vervang de gemarkeerde IP's door de IP-adressen van je Ansible-hosts.
/etc/ansible/hosts
[ubuntu-server]
ubuntu-server ansible_host=192.168.182.130
[loadbalancers]
[servers]
server1 ansible_host=10.13.37.10
server2 ansible_host=10.13.37.11
server3 ansible_host=10.13.37.12
[database_servers]
[all_servers:children]
[all:vars]
ansible_connection=ssh
ansible_user=student
ansible_python_interpreter=/usr/bin/python3
De all:varssubgroep stelt de ansible_python_interpreterhost parameter in die geldig is voor alle hosts die in deze inventaris zijn opgenomen. Deze parameter zorgt ervoor dat de externe server het /usr/bin/python3uitvoerbare bestand Python3 gebruikt in plaats van /usr/bin/python(Python 2.7), dat niet aanwezig is in recente Ubuntu-versies. Daarnaast zie je de connection type SSH is en dat voor alle servers geldt dat er een gebruiker student is. Verschilt dat per configuratie? dan moet je het niet opnemen in je hosts inventarisbestand.
Wanneer je klaar bent, Opslaan en sluiten van het bestand door CTRL+Xte drukken, dan Yen ENTERom de wijzigingen te bevestigen.
Wanneer je de inventaris wilt controleren, kun je het volgende uitvoeren:
ansible-inventory --list -y
U zult vergelijkbare uitvoer zien, maar met uw eigen serverinfrastructuur zoals gedefinieerd in uw inventarisbestand:
all:
children:
all_servers: {}
database_servers: {}
loadbalancers: {}
servers:
hosts:
server1:
ansible_connection: ssh
ansible_host: 10.13.37.10
ansible_python_interpreter: /usr/bin/python3
ansible_user: student
server2:
ansible_connection: ssh
ansible_host: 10.13.37.11
ansible_python_interpreter: /usr/bin/python3
ansible_user: student
server3:
ansible_connection: ssh
ansible_host: 10.13.37.12
ansible_python_interpreter: /usr/bin/python3
ansible_user: student
ubuntu-server:
hosts:
ubuntu-server:
ansible_connection: ssh
ansible_host: 192.168.182.130
ansible_python_interpreter: /usr/bin/python3
ansible_user: student
ungrouped: {}
Nu je je inventarisbestand hebt geconfigureerd, heb je alles wat je nodig hebt om de verbinding met je Ansible-hosts te testen.
Verbinding testen
Nadat je het inventarisbestand hebt ingesteld om alle servers op te nemen, is het tijd om te controleren of Ansible verbinding kan maken met deze servers en opdrachten kan uitvoeren via SSH.
Voor deze les gebruiken we het Ubuntu- student account, omdat dit het sudo-gebruiker account is dat we hebben ingesteld. Dit is beter dan het ROOT-account en je wordt aangemoedigd om dat account te gebruiken.
Je kunt het -uoptie gebruiken om de externe systeemgebruiker op te geven. Als dit niet het geval is, zal Ansible proberen verbinding te maken als je huidige systeemgebruiker op het controleknooppunt. Wij hebben in het inventartisbestand aangegeven dat onze gebruikent student is en hoeven we de optie -u niet te gebruiken.
Voer vanaf je lokale computer of Ansible-besturingsknooppunt het volgende uit:
ansible all -m ping
Voor alle servers in je inventarisbestand, anders:
ansible -m ping ubuntu-server
Deze opdracht gebruikt de ingebouwde pingmodule van Ansible om een connectiviteitstest uit te voeren op alle knooppunten vanuit je standaardinventaris, waarbij je verbinding maakt als student . De pingmodule test:
- of hosts toegankelijk zijn;
- als je geldige SSH-inloggegevens hebt;
- als hosts Ansible-modules kunnen draaien met Python.
Je zou een output moeten krijgen die lijkt op deze:
ubuntu-server | SUCCESS => {
"changed": false,
"ping": "pong"
Als dit de eerste keer is dat je via SSH verbinding maakt met deze servers, wordt je gevraagd om de authenticiteit te bevestigen van de hosts waarmee je verbinding maakt via Ansible. Typ wanneer daarom wordt gevraagd yesen druk op ENTERom te bevestigen.
Zodra je een "pong"antwoord van een host ontvangt, betekent dit dat je klaar bent om Ansible-opdrachten en playbooks op die server uit te voeren.
Ad-hoc opdrachten met Ansible
Nadat je hebt bevestigd dat je Ansible-host kan communiceren met je hosts, kun je ad-hoc opdrachten en playbooks op je servers uitvoeren.
Elke opdracht die je normaal gesproken via SSH op een externe server zou uitvoeren, kan met Ansible worden uitgevoerd op de servers die in je inventarisbestand zijn opgegeven. Je kunt bijvoorbeeld het schijfgebruik op alle servers controleren met:
ansible all -a "df -h"
of op 1 server:
ansible ubuntu-server -a "df -h"
ubuntu-server | CHANGED | rc=0 >>
Filesystem Size Used Avail Use% Mounted on
udev 1.9G 0 1.9G 0% /dev
tmpfs 391M 1.3M 390M 1% /run
/dev/mapper/ubuntu--vg-ubuntu--lv 29G 6.6G 21G 24% /
tmpfs 2.0G 0 2.0G 0% /dev/shm
tmpfs 5.0M 0 5.0M 0% /run/lock
tmpfs 2.0G 0 2.0G 0% /sys/fs/cgroup
/dev/sda2 976M 198M 712M 22% /boot
/dev/loop0 55M 55M 0 100% /snap/core18/1880
/dev/loop1 72M 72M 0 100% /snap/lxd/16099
/dev/loop2 56M 56M 0 100% /snap/core18/1988
/dev/loop3 32M 32M 0 100% /snap/snapd/11036
/dev/loop4 30M 30M 0 100% /snap/snapd/8542
/dev/loop5 70M 70M 0 100% /snap/lxd/19188
tmpfs 391M 0 391M 0% /run/user/1001
De gemarkeerde opdracht df -hkan worden vervangen door elke gewenste opdracht.
Je kunt Ansible-modules ook uitvoeren via ad-hoc-opdrachten, vergelijkbaar met wat we eerder hebben gedaan met de pingmodule voor het testen van de verbinding. Dit is bijvoorbeeld hoe we de aptmodule kunnen gebruiken om de nieuwste versie van vimop alle servers in je inventaris te installeren :
ansible all -m apt -a "name=vim state=latest"
of op 1 server:
ansible ubuntu-server -m apt -a "name=vim state=latest"
Je kunt je ook richten op individuele hosts, evenals groepen en subgroepen, wanneer je Ansible-opdrachten uitvoert. Dit is bijvoorbeeld hoe je de uptimevan elke host in de serversgroep zou controleren :
ansible servers -a "uptime"
We kunnen meerdere hosts specificeren door ze te scheiden met dubbele punten:
ansible server1:server2 -m ping
Voor meer informatie over het gebruik van Ansible, ga naar de officiële website van Ansible voor heel veel informatie over het gebruik van Ansible opdrachten.
Laten we kijken naar de kracht van Ansible en dat zijn Ansible-playbooks
Apache ansible-playbook
We gaan eerst een mappen structuur maken om onze Ansible-playbook bestanden netjes in weg te zetten. Maak in je ~/Documents een directory "ansible/apache". In deze directory gaan we werken en ervoor zorgen dat onze bestanden gestructureerd zijn voor het gebruik van Ansible.
Ik werk in Visual studio code omdat we hierin een gestructureerde editor en terminal tegelijk hebben. Mocht je dit niet fijn vinden dan is de CLI ook goed, vindt hierin je eigen werkwijze.
Laten we beginnen met de bestanden dat we minimaal nodig zijn. In de directory /vars/ die in de apache directory zit maken we een bestand default.yml
---
app_user: "student"
http_host: "scooters.inc"
http_conf: "scooters.inc.conf"
http_port: "80"
disable_default: true
We zien een aantal default instellingen die we dadelijk in onze playbook kunnen gebruiken. Dit is een manier van werken, je kunt ze in je playbook ook elke keer uitschrijven.
Nu maken we een directory /files/ met daarin 2 bestanden. We maken onze apache configuratie hierin en de index.html voor de website.
apache.conf.j2
<VirtualHost *:{{ http_port }}>
ServerAdmin webmaster@localhost
ServerName {{ http_host }}
ServerAlias www.{{ http_host }}
DocumentRoot /var/www/{{ http_host }}
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
index.html.j2
<html>
<head>
<title>Welcome to {{ http_host }} !</title>
</head>
<body>
<h1>Success! The {{ http_host }} virtual host is working!</h1>
</body>
</html>
Als we deze bestanden hebben gemaakt kunnen we aan de slag met je playbook. In de ansible-playbook komen stap voor stap de configuraties die gedaan moeten worden. Bedenk welke stappen/installaties/instellingen je zelf hebt gedaan als Apache2 installeerd op 1 server. Deze stappen gaan we nu benoemen in de playbook.
in de apache directory maak je playbook.yml
---
- hosts: ubuntu-server
become: true
vars_files:
- vars/default.yml
tasks:
- name: Install prerequisites
apt: name={{ item }} update_cache=yes state=latest force_apt_get=yes
loop: [ 'aptitude' ]
- name: Install Apache
apt: name=apache2 update_cache=yes state=latest
- name: Create document root
file:
path: "/var/www/{{ http_host }}"
state: directory
owner: "{{ app_user }}"
mode: '0755'
- name: Copy index test page
template:
src: "files/index.html.j2"
dest: "/var/www/{{ http_host }}/index.html"
- name: Set up Apache virtuahHost
template:
src: "files/apache.conf.j2"
dest: "/etc/apache2/sites-available/{{ http_conf }}"
- name: Enable new site
shell: /usr/sbin/a2ensite {{ http_conf }}
notify: Reload Apache
- name: Disable default Apache site
shell: /usr/sbin/a2dissite 000-default.conf
when: disable_default
notify: Reload Apache
- name: "UFW - Allow HTTP on port {{ http_port }}"
ufw:
rule: allow
port: "{{ http_port }}"
proto: tcp
handlers:
- name: Reload Apache
service:
name: apache2
state: reloaded
- name: Restart Apache
service:
name: apache2
state: restarted
Het is onzettend belangrijk dat je de .yml bestanden op de bovenstaanden manier opbouwd. Mochten hier fouten in zitten qua spaties en bestandsformaat dan gaat het niet werken en krijg je fout meldingen. Zoek eens uit hoe een yaml file wordt gemaakt, opgebouwd wordt en yaml kan alleen werken als je hier rekening mee houdt.
Belangrijk!
---
- hosts: ubuntu-server
become: true
vars_files:
- vars/default.yml
Bij hosts staat nu ubuntu-server, hier kan ook je serverblock staan als het om meerdere servers gaat.
become: true betekend dat je als root user dit gaat uitvoeren, vergelijk het met de opdracht sudo. Hiervoor moeten we 1 keer ons wachtwoord invullen, dit moeten we straks ook als we deze playbook gaan uitvoeren. Wil je dit niet, dan laat je het weg. Het kan zo zijn dat bepaalde opdrachten alleen als root uitgevoerd mogen worden binnen Linux.
De playbook uitvoeren
Om deze playbook uit te voeren gebruiken we de volgende opdracht:
ansible-playbook --ask-become-pass playbook.yml
Je voert je wachtwoord in en de playbook wordt uitgevoerd. Magie! (de eerste keer).
PLAY [ubuntu-server] *************************************************************************************************************************************************************
TASK [Gathering Facts] ***********************************************************************************************************************************************************
ok: [ubuntu-server]
TASK [Install prerequisites] *****************************************************************************************************************************************************
changed: [ubuntu-server] => (item=aptitude)
TASK [Install Apache] ************************************************************************************************************************************************************
changed: [ubuntu-server]
TASK [Create document root] ******************************************************************************************************************************************************
changed: [ubuntu-server]
TASK [Copy index test page] ******************************************************************************************************************************************************
changed: [ubuntu-server]
TASK [Set up Apache virtuahHost] *************************************************************************************************************************************************
changed: [ubuntu-server]
TASK [Enable new site] ***********************************************************************************************************************************************************
changed: [ubuntu-server]
TASK [Disable default Apache site] ***********************************************************************************************************************************************
changed: [ubuntu-server]
TASK [UFW - Allow HTTP on port 80] ***********************************************************************************************************************************************
changed: [ubuntu-server]
RUNNING HANDLER [Reload Apache] **************************************************************************************************************************************************
changed: [ubuntu-server]
PLAY RECAP ***********************************************************************************************************************************************************************
ubuntu-server : ok=10 changed=9 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
In de uitvoer zie je uiteindelijk dat er 10=ok zijn en changed=9. Er zijn dit 9 dingen aangepast op de server. Laten we naar het IP-adres gaan in je URL om de zien of het gelukt is.
Website uitrollen met Ansible
Nu we de configuratie van Apache in een handomdraai hebben gedaan, gaan we kijken naar het kopiëren van bestanden naar de webserver. In dit voorbeeld heb ik in de directory /file/ een directory gemaakt met de naam full-website. In deze directory zitten alle bestanden voor deze website, zoals de index, css, afbeeldingen, enz.
Plaats jouw website in de bovengenoemde directory en laten we een copy-website.yml playbook maken om onze website automatisch uit te rollen.
---
- hosts: ubuntu-server
become: true
vars_files:
- vars/default.yml
tasks:
- name: Copy complete website
copy:
src: "files/full-website/"
dest: "/var/www/{{ http_host }}"
handlers:
- name: Reload Apache
service:
name: apache2
state: reloaded
- name: Restart Apache
service:
name: apache2
state: restarted
zorg ervoor dat de bovenstaande verwijzingen overeenkomen met jouw situatie.
We gaan de playbook uitvoeren met:
ansible-playbook --ask-become-pass copy-website.yml
Vul je wachtwoord in en je website zal snel zichtbaar zijn op de webserver.
PLAY [ubuntu-server] *************************************************************************************************************************************************************
TASK [Gathering Facts] ***********************************************************************************************************************************************************
ok: [ubuntu-server]
TASK [Copy complete website] *****************************************************************************************************************************************************
changed: [ubuntu-server]
PLAY RECAP ***********************************************************************************************************************************************************************
ubuntu-server : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Nu ben je in staat lokaal aanpassingen te doen aan configuraties en deze automatisch uit te rollen over meerdere servers. Het aantal is nu ondergeschikt geworden.
Les 2: Nginx
Deze les gaan we aan de slag met de 2de populaire webserver "nginx". Naast Apache wordt nginx veel gebruikt als webserver en doet in de basis hetzelfde, zorgen dat je website online staat. Echter qua configuratie zitten er wel wat verschillen.
Voorbereiding:
- Zorg ervoor dat alle Apache processen uit voorgaande les gestopt zijn.
- Apache met APT verwijderen
- Controleren of de map /var/www leeg is
- Zoek naar Apache processen op de server en "kill" deze
- deny apache in UFW
of
- Ga terug naar je snapshot dat de ubuntu-server helemaal basis gereed was. (Aanbevolen!)
Nginx installeren
Omdat Nginx beschikbaar is in de standaard repositories van Ubuntu, is het mogelijk om het vanuit deze repositories te installeren met behulp van het aptverpakkingssysteem.
Aangezien dit onze eerste interactie met het aptverpakkingssysteem in deze sessie is, zullen we onze lokale pakketindex bijwerken zodat we toegang hebben tot de meest recente pakketvermeldingen. Daarna kunnen we installeren nginx:
sudo apt update
sudo apt install nginx
Na het accepteren van de procedure, aptzal Nginx en alle vereiste afhankelijkheden op uw server installeren.
Firewall (UFW) aanpassen
Voordat je Nginx test, moet de firewall worden aangepast om toegang tot de service mogelijk te maken. Nginx registreert zichzelf als een service bij ufwbij installatie, waardoor het eenvoudig is om Nginx-toegang toe te staan.
Maak een lijst van de applicatieconfiguraties die ufwweten hoe ze moeten werken door te typen:
sudo ufw app list
Je zou een lijst met de toepassingsprofielen moeten krijgen
Zoals blijkt uit de uitvoer, zijn er drie profielen beschikbaar voor Nginx:
- Nginx Full : dit profiel opent zowel poort 80 (normaal, niet-versleuteld webverkeer) als poort 443 (TLS / SSL-versleuteld verkeer)
- Nginx HTTP : dit profiel opent alleen poort 80 (normaal, niet-versleuteld webverkeer)
- Nginx HTTPS : dit profiel opent alleen poort 443 (TLS / SSL versleuteld verkeer)
Het wordt aanbevolen dat je het meest beperkende profiel inschakelt dat nog steeds het door je geconfigureerde verkeer toelaat. Op dit moment hoeven we alleen verkeer op poort 80 toe te staan.
U kunt dit inschakelen door te typen:
sudo ufw allow 'Nginx HTTP'
U kunt de wijziging verifiëren door te typen:
sudo ufw status
De uitvoer geeft aan welk HTTP-verkeer is toegestaan:
De webserver controleren
Aan het einde van het installatieproces start Ubuntu 20.04 Nginx. De webserver zou al actief moeten zijn.
We kunnen met het systemdinit-systeem controleren of de service actief is door te typen:
systemctl status nginx
Zoals bevestigd, is de service met succes gestart. De beste manier om dit te testen, is door daadwerkelijk een pagina bij Nginx op te vragen.
Je kunt de standaard Nginx-bestemmingspagina openen om te bevestigen dat de software correct werkt door naar het IP-adres van uw server te navigeren.
Als je het IP-adres van je server hebt, voer je dit in de adresbalk van je browser in:
http://your_server_ip
U zou de standaard Nginx-bestemmingspagina moeten ontvangen
Beheren van nginx processen
Nu je webserver actief is, gaan we enkele basisbeheeropdrachten bekijken.
Om uw webserver te stoppen, typ je:
sudo systemctl stop nginx
Om de webserver te starten wanneer deze is gestopt, typ je:
sudo systemctl start nginx
Om de service te stoppen en opnieuw te starten, typ je:
sudo systemctl restart nginx
Als je alleen configuratiewijzigingen aanbrengt, kan Nginx vaak opnieuw laden zonder verbindingen te verbreken. Typ hiervoor:
sudo systemctl reload nginx
Nginx is standaard geconfigureerd om automatisch te starten wanneer de server opstart. Als dit niet is wat je wilt, kun je dit gedrag uitschakelen door te typen:
sudo systemctl disable nginx
Om de service opnieuw in te schakelen om bij het opstarten te starten, kun je typen:
sudo systemctl enable nginx
Je hebt nu basisbeheeropdrachten geleerd en je zou klaar moeten zijn om de site te configureren om meer dan één domein te hosten.
Server blokken instellen
Bij gebruik van de Nginx-webserver kunnen serverblokken (vergelijkbaar met virtuele hosts in Apache) worden gebruikt om configuratiedetails in te kapselen en meer dan één domein te hosten vanaf een enkele server. We zullen een domein opzetten met de naam noorderpoort, maar je moet dit vervangen door je eigen domeinnaam.
Nginx op Ubuntu 20.04 heeft standaard één serverblok ingeschakeld dat is geconfigureerd om documenten uit een map op /var/www/html. Hoewel dit goed werkt voor een enkele site, kan het onpraktisch worden als je meerdere sites host. /var/www/htmlLaten we, in plaats van te wijzigen, een directory-structuur aanmaken /var/wwwvoor onze site noorderpoort, en laten we deze /var/www/htmlals de standaard directory gebruiken als een verzoek van een klant niet overeenkomt met andere sites.
Maak de map voor noorderpoort als volgt, gebruik de -pvlag om de benodigde bovenliggende mappen te maken:
sudo mkdir -p /var/www/noorderpoort/html
Wijs vervolgens het eigendom van de directory toe met de $USERomgevingsvariabele:
sudo chown -R $USER:$USER /var/www/noorderpoort/html
De naam noorderpoort is gekozen door mij, deze mag je naar eigen wens aanpassen.
Maak vervolgens een voorbeeldpagina index.htmlmet nanoof je favoriete editor:
nano /var/www/noorderpoort/html/index.html
Voeg een voorbeeld-HTML toe.
Om Nginx deze inhoud te laten leveren, is het nodig om een serverblok met de juiste richtlijnen te maken. In plaats van het standaard configuratiebestand rechtstreeks te wijzigen, laten we een nieuw bestand maken op :/etc/nginx/sites-available/noorderpoort
sudo nano /etc/nginx/sites-available/noorderpoort
Maak het volgende configuratieblok, dat vergelijkbaar is met het standaard, maar bijgewerkt voor onze nieuwe directory en domeinnaam:
server {
listen 80;
listen [::]:80;
root /var/www/noorderpoort/html;
index index.html index.htm;
server_name noorderpoort www.noorderpoort;
location / {
try_files $uri $uri/ =404;
}
}
Merk op dat we de rootconfiguratie hebben bijgewerkt naar onze nieuwe directory en de server_namenaar onze domeinnaam.
Laten we vervolgens het bestand inschakelen door er een link van te maken naar de sites-enableddirectory, waaruit Nginx leest tijdens het opstarten:
sudo ln -s /etc/nginx/sites-available/noorderpoort /etc/nginx/sites-enabled/
Twee server blokken zijn nu ingeschakeld en geconfigureerd om te reageren op verzoeken op basis van hun listenen server_namerichtlijnen.
your_domain: Zal reageren op verzoeken om your_domainen www.your_domain.default: Reageert op alle verzoeken op poort 80 die niet overeenkomen met de andere twee blokken.
Om een mogelijk hash-bucket-geheugenprobleem te vermijden dat kan ontstaan door het toevoegen van extra servernamen, is het nodig om een enkele waarde in het /etc/nginx/nginx.confbestand aan te passen. Open het bestand:
sudo nano /etc/nginx/nginx.conf
Zoek de server_names_hash_bucket_sizerichtlijn en verwijder het #symbool om het commentaar op de regel te verwijderen.
Test vervolgens om er zeker van te zijn dat er geen syntaxisfouten zijn in uw Nginx-bestanden:
sudo nginx -t
Als er geen problemen zijn, start je Nginx opnieuw om uw wijzigingen door te voeren:
sudo systemctl restart nginx
Nginx zou nu je domeinnaam/IP-adres moeten bedienen
Debug:
- Het kan zijn dat Nginx de default page blijft serveren.
- In /etc/nginx/sites-available zit het default bestand. Verwijder het default bestand
- in /etc/nginx/sites-enabled staat de symlink nog van de default. Ook deze verwijderen!
- Test de configuratie
- Herstart Nginx
- Denk om je Firewall
Nginx bestanden en mappen
Inhoud
/var/www/html: De feitelijke webinhoud, die standaard alleen bestaat uit de standaard Nginx-pagina die je eerder zag, wordt uit de /var/www/htmldirectory geserveerd. Dit kan worden gewijzigd door Nginx-configuratiebestanden te wijzigen.
Serverconfiguratie
/etc/nginx: De Nginx-configuratiemap. Alle configuratiebestanden van Nginx bevinden zich hier./etc/nginx/nginx.conf: Het hoofdconfiguratiebestand van Nginx. Dit kan worden gewijzigd om wijzigingen aan te brengen in de globale configuratie van Nginx./etc/nginx/sites-available/: De directory waar serverblokken per site kunnen worden opgeslagen. Nginx zal de configuratiebestanden in deze directory niet gebruiken, tenzij ze aan de sites-enableddirectory zijn gekoppeld . Gewoonlijk wordt alle serverblokconfiguratie in deze directory uitgevoerd en vervolgens ingeschakeld door te linken naar de andere directory./etc/nginx/sites-enabled/: De map waarin ingeschakelde serverblokken per site worden opgeslagen. Deze worden doorgaans gemaakt door te linken naar configuratiebestanden in de sites-availabledirectory./etc/nginx/snippets: Deze map bevat configuratiefragmenten die elders in de Nginx-configuratie kunnen worden opgenomen. Mogelijk herhaalbare configuratiesegmenten zijn goede kandidaten voor herstructurering in fragmenten.
Serverlogboeken
/var/log/nginx/access.log: Elk verzoek aan je webserver wordt geregistreerd in dit logbestand, tenzij Nginx is geconfigureerd om iets anders te doen./var/log/nginx/error.log: Eventuele NGINX-fouten worden in dit logboek geregistreerd.
Snapshot maken
Als de configuratie gelukt is, maak dan een snapshot met de naam "Nginx configuratie compleet".
Opdracht Nginx webserver
De opdracht staat op ItsLearning, goed lezen, opdracht maken en inleveren op ItsLearning.
Uitdaging: Nginx
Automatiseer met Ansible je Nginx applicatie en de uitrol hiervan. Laat zien dat je je configuratie kunt aanpassen met Ansible.
Playbook Nginx
Hieronder de playbook.yml voor de nginx-server.
---
- hosts: ubuntu-server
tasks:
- name: ensure nginx is at the latest version
apt: name=nginx state=latest
become: yes
- name: start nginx
service:
name: nginx
state: started
become: yes
- name: copy the nginx config file and restart nginx
copy:
src: static-site.cfg
dest: /etc/nginx/sites-available/static_site.cfg
become: yes
- name: create symlink
file:
src: /etc/nginx/sites-available/static_site.cfg
dest: /etc/nginx/sites-enabled/default
state: link
become: yes
- name: copy the content of the web site
copy:
src: "static-site/"
dest: "/home/student/static-site"
- name: restart nginx
service:
name: nginx
state: restarted
become: yes
- name: "UFW - Allow HTTP on port 80"
ufw:
rule: allow
port: "80"
proto: tcp
become: yes
Zorg dat dit configuratie bestand in dezelfde directory zit met de naam static-site.cfg
server {
listen 80 default_server;
listen [::]:80 default_server;
root /home/student/static-site;
index index.html index.htm;
server_name noorderpoort;
location / {
try_files $uri $uri/ =404;
}
}
In de directory van de playbook maar je een directory met de naam static-site, hierin plaats je de index.html en eventueel een afbeelding. Zorg dat de verwijzingen in je playbook overeenkomen met wat in jouw directory staat. Naamgevingen zijn hier een voorbeeld, maar kijk goed dat dit overeenkomt.
Na het deployen van je playbook zou je nginx-website beschikbaar moeten zijn op het IP-adres.
Les 3: LAMP
Een "LAMP" -stack is een groep open-source software die doorgaans samen wordt geïnstalleerd om een server in staat te stellen dynamische websites en webapps te hosten die zijn geschreven in PHP. Deze term is een afkorting die staat voor Linux besturingssysteem, de Apache webserver. De site data wordt opgeslagen in een MySQL database en dynamische inhoud wordt verwerkt door PHP.
Voorbereiding:
- Zorg ervoor dat alle nginx processen uit voorgaande les gestopt zijn.
- Nginx met APT verwijderen
- Controleren of de map /var/www leeg is
- Zoek naar nginx processen op de server en "kill" deze
- deny nginx in UFW
of
- Ga terug naar je snapshot dat de ubuntu-server helemaal basis gereed was. (Aanbevolen!)
Apache2 installeren
Zoals in eerdere lessen beginnen we met de installatie van Apache2 en voegen we de applicatie toe aan de firewall.
Laten we beginnen met het bijwerken van de lokale pakketindex om de laatste upstream-wijzigingen weer te geven:
sudo apt update
Installeer vervolgens het apache2pakket:
sudo apt install apache2
Na bevestiging van de installatie, aptinstalleert Apache en alle vereiste afhankelijkheden.
UFW
Voordat u Apache test, is het noodzakelijk om de firewall-instellingen te wijzigen om externe toegang tot de standaardwebpoorten toe te staan. Ervan uitgaande dat u de instructies in de vereisten hebt gevolgd, zou u een UFW-firewall moeten hebben geconfigureerd om de toegang tot uw server te beperken.
Maak een lijst van de ufwapplicatieprofielen door te typen:
sudo ufw app list
Het wordt aanbevolen om het meest beperkende profiel in te schakelen dat nog steeds het door u geconfigureerde verkeer toelaat. Aangezien we in deze handleiding nog geen SSL voor onze server hebben geconfigureerd, hoeven we alleen verkeer op poort 80 toe te staan:
sudo ufw allow Apache
U kunt de wijziging verifiëren door te typen:
sudo ufw status
Controleer of Apache opgestart is door naar het IP-adres van de server te gaan in Firefox.
MySQL installeren
Nu je een webserver hebt, moet je het databasesysteem installeren om gegevens voor je site op te kunnen slaan en te beheren. MySQL is een populair databasebeheersysteem dat wordt gebruikt in PHP-omgevingen.
Nogmaals, gebruik aptom deze software te verkrijgen en te installeren:
sudo apt install mysql-server
Bevestig de installatie wanneer daarom wordt gevraagd door te typen Yen vervolgens ENTER.
Wanneer de installatie is voltooid, wordt aanbevolen dat je een beveiligingsscript uitvoert dat vooraf is geïnstalleerd met MySQL. Dit script zal enkele onveilige standaardinstellingen verwijderen en de toegang tot uw databasesysteem vergrendelen. Start het interactieve script door uit te voeren:
sudo mysql_secure_installation
Dit zal je vragen of je het VALIDATE PASSWORD PLUGIN.
Antwoord Yvoor ja, aanbevolen is om dit in te schakelen.
Als je "ja" antwoordt, wordt je gevraagd een wachtwoordvalidatieniveau te selecteren. Houd er rekening mee dat als je invoert 2voor het sterkste niveau, je foutmeldingen krijgt als je probeert een wachtwoord in te stellen dat geen cijfers, hoofdletters en kleine letters en speciale tekens bevat, of dat is gebaseerd op veelgebruikte woordenboekwoorden.
Ongeacht of je ervoor heeft gekozen om het in te stellen VALIDATE PASSWORD PLUGIN, de server zal je vervolgens vragen om een wachtwoord voor de MySQL- rootgebruiker te selecteren en te bevestigen. Dit moet niet worden verward met de systeemroot. De database-rootgebruiker is een administratieve gebruiker met volledige rechten over het databasesysteem. Hoewel de standaardverificatiemethode voor de MySQL-rootgebruiker het gebruik van een wachtwoord voorschrijft, moet je hier als extra veiligheidsmaatregel een sterk wachtwoord definiëren, zelfs als er een is ingesteld.
Als je wachtwoordvalidatie hebt ingeschakeld, krijg je de wachtwoordsterkte te zien voor het root-wachtwoord dat je zojuist hebt ingevoerd en zal je server vragen of je met dat wachtwoord wilt doorgaan. Als u tevreden bent met uw huidige wachtwoord, voer dan Yvoor "ja" in bij de prompt.
Voor de rest van de vragen, druk op Yen druk op de ENTERtoets bij elke prompt. Dit zal enkele anonieme gebruikers en de testdatabase verwijderen, root-logins op afstand uitschakelen en deze nieuwe regels laden zodat MySQL onmiddellijk de wijzigingen respecteert die je hebt aangebracht.
Als je klaar bent, test je of je kunt aanmelden bij de MySQL-console door te typen:
sudo mysql
Dit zal verbinding maken met de MySQL-server als de root van de gebruiker van de administratieve database, wat wordt afgeleid uit het gebruik van sudobij het uitvoeren van deze opdracht.
Om de MySQL-console af te sluiten, typt u:
exit
Voor een betere beveiliging is het het beste om voor elke database speciale gebruikersaccounts met minder uitgebreide privileges te hebben, vooral als je van plan bent om meerdere databases op uw server te laten hosten.
Je MySQL-server is nu geïnstalleerd en beveiligd. Vervolgens installeren we PHP, het laatste onderdeel in de LAMP-stack.
PHP installeren
Je hebt Apache geïnstalleerd om je inhoud aan te bieden en MySQL is geïnstalleerd om je gegevens op te slaan en te beheren. PHP is het onderdeel van onze setup dat code verwerkt om dynamische inhoud weer te geven aan de eindgebruiker. Naast het phppakket heb je php-mysqleen PHP-module nodig waarmee PHP kan communiceren met op MySQL gebaseerde databases. Je moet ook libapache2-mod-phpApache inschakelen om PHP-bestanden te verwerken. Core PHP-pakketten worden automatisch geïnstalleerd als afhankelijkheden.
Om deze pakketten te installeren, voer je uit:
sudo apt install php libapache2-mod-php php-mysql
Zodra de installatie is voltooid, kun je de volgende opdracht uitvoeren om uw PHP-versie te bevestigen:
php -v
Op dit punt is je LAMP-stack volledig operationeel, maar voordat je je setup kunt testen met een PHP-script, kun je het beste eenApache Virtual Host opzetten om de bestanden en mappen van je website op te slaan.
Virtuele host voor je website maken
Net als in de Apache les gaan we een virtuele host maken voor onze website. Deze is precies hetzelfde als de vorige les. Na het aanmaken van de virtuele host gaan we aan de slag met MySQL en PHP.
Voorbeeld: In dit voorbeeld is er gekozen voor de domein naam noorderpoort, dit kun je naar eigen wens aanpassen naar een andere domeinnaam.
Apache op Ubuntu 20.04 heeft standaard één serverblok ingeschakeld dat is geconfigureerd om documenten uit de /var/www/htmlmap te serveren. Hoewel dit goed werkt voor een enkele site, kan het onpraktisch worden als u meerdere sites host. In plaats van te wijzigen /var/www/html, maken we een directorystructuur binnen /var/wwwvoor een site met uw_domein, en laten we deze /var/www/htmlop zijn plaats als de standaarddirectory die wordt bediend als een verzoek van een klant niet overeenkomt met andere sites.
Maak de map voor uw_domein als volgt:
sudo mkdir /var/www/noorderpoort
Wijs vervolgens het eigendom van de directory toe met de $USERomgevingsvariabele:
sudo chown -R $USER:$USER /var/www/noorderpoort
Maak vervolgens een voorbeeldpagina index.htmlmet nanoof uw favoriete editor:
sudo nano /var/www/noorderpoort/index.html
Voeg binnen de index.html een stuk html toe zodat Apache deze kan serveren.
Om Apache deze inhoud te laten leveren, is het nodig om een virtueel hostbestand met de juiste richtlijnen te maken. In plaats van het standaard configuratiebestand te wijzigen dat zich /etc/apache2/sites-available/000-default.confdirect op bevindt, laten we een nieuw bestand maken op:/etc/apache2/sites-available/your_domain.conf
sudo nano /etc/apache2/sites-available/noorderpoort.conf
Maak het volgende configuratieblok, dat vergelijkbaar is met het standaard, maar bijgewerkt voor onze nieuwe directory en domeinnaam:
Sla het bestand op en sluit het als u klaar bent.
Laten we het bestand inschakelen met de a2ensitetool:
sudo a2ensite noorderpoort.conf
Schakel de standaardsite uit die is gedefinieerd in 000-default.conf:
sudo a2dissite 000-default.conf
Laten we vervolgens testen op configuratiefouten:
sudo apache2ctl configtest
U zou de volgende uitvoer moeten ontvangen:
Output
Syntax OK
Start Apache opnieuw om uw wijzigingen door te voeren:
sudo systemctl restart apache2
Apache zou nu uw domeinnaam moeten bedienen. U kunt dit testen door te navigeren naar, waar u zoiets als dit zou moeten zien:http://IP_van_je_server
Directory index configuratie
Met de standaardinstellingen DirectoryIndexop Apache heeft een bestand met de naam index.htmlaltijd voorrang op een index.phpbestand. Dit is handig voor het opzetten van onderhoudspagina's in PHP-applicaties, door een tijdelijk index.htmlbestand aan te maken met daarin een informatief bericht voor bezoekers. Omdat deze pagina voorrang heeft op de index.phppagina, wordt deze de bestemmingspagina voor de applicatie. Zodra het onderhoud voorbij is, index.htmlwordt het hernoemd of verwijderd uit de documentroot, waardoor de normale toepassingspagina terugkeert.
Als je dit gedrag wilt wijzigen, moet je het /etc/apache2/mods-enabled/dir.confbestand bewerken en de volgorde wijzigen waarin het index.phpbestand in de DirectoryIndexrichtlijn wordt vermeld :
sudo nano /etc/apache2/mods-enabled/dir.conf
/etc/apache2/mods-enabled/dir.conf
<IfModule mod_dir.c>
DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
</IfModule>
Nadat je het bestand hebt opgeslagen en gesloten, moet je Apache opnieuw laden zodat de wijzigingen van kracht worden:
sudo systemctl reload apache2
In de volgende stap maken we een PHP-script om te testen of PHP correct is geïnstalleerd en geconfigureerd op je server.
PHP verwerking testen
Nu je een aangepaste locatie hebt om de bestanden en mappen van je website te hosten, zullen we een PHP-testscript maken om te bevestigen dat Apache verzoeken voor PHP-bestanden kan afhandelen en verwerken.
Maak een nieuw bestand met de naam info.phpin je aangepaste web-hoofdmap:
nano /var/www/noorderpoort/info.php
Hierdoor wordt een leeg bestand geopend. Voeg de volgende tekst, die geldige PHP-code is, toe aan het bestand:
/var/www/noorderpoort/info.php
<?php
phpinfo();
?>
Als je klaar bent, sla het bestand op en sluit je het.
Om dit script te testen, ga je naar je webbrowser en open je het IP-adres van je server, gevolgd door de scriptnaam, in dit geval info.php:
http://server_domain_or_IP/info.php
Je ziet een pagina met phpinfo.
Deze pagina geeft informatie over je server vanuit het perspectief van PHP. Het is handig voor foutopsporing en om ervoor te zorgen dat je instellingen correct worden toegepast.
Als je deze pagina in je browser kunt zien, werkt je PHP-installatie zoals verwacht.
Nadat je via die pagina de relevante informatie over je PHP-server heeft gecontroleerd, kun je het door je gemaakte bestand het beste verwijderen, aangezien dit gevoelige informatie over je PHP-omgeving en je Ubuntu-server bevat. Je kunt hiervoor gebruik rmmaken van:
sudo rm /var/www/noorderpoort/info.php
Je kunt deze pagina altijd opnieuw maken als je de informatie later opnieuw nodig hebt.
Database maken
Als je wilt testen of PHP in staat is om verbinding te maken met MySQL en databasequery's uit te voeren, kun je een testtabel maken met dummy-gegevens en een query naar de inhoud ervan vanuit een PHP-script. Voordat we dat kunnen doen, moeten we een testdatabase maken en een nieuwe MySQL-gebruiker die correct is geconfigureerd om er toegang toe te krijgen.
We maken een database met de naam test_database en een gebruiker met de naam test_user , maar je kunt deze namen vervangen door een andere naam.
Maak eerst verbinding met de MySQL-console met behulp van het root account:
sudo mysql
Om een nieuwe database te maken, voer je de volgende opdracht uit vanaf je MySQL-console:
CREATE DATABASE test_database;
Nu kun je een nieuwe gebruiker aanmaken en hem volledige rechten verlenen op de aangepaste database die je zojuist hebt gemaakt.
Met de volgende opdracht maakt u een nieuwe gebruiker met de naam test_user, met mysql_native_passwordals standaardverificatiemethode. We definiëren het wachtwoord van deze gebruiker als password, maar je moet deze waarde vervangen door een veilig wachtwoord naar keuze.
CREATE USER 'test_user'@'%' IDENTIFIED WITH mysql_native_password BY 'password';
Nu moeten we deze gebruiker toestemming geven voor de test_databasedatabase:
GRANT ALL ON test_database.* TO 'test_user'@'%';
Dit geeft de gebruiker test_user volledige rechten over de database test_database, terwijl wordt voorkomen dat deze gebruiker andere databases op je server maakt of wijzigt.
Verlaat nu de MySQL-shell met:
exit
Je kunt testen of de nieuwe gebruiker de juiste rechten heeft door opnieuw in te loggen op de MySQL-console, dit keer met behulp van de aangepaste gebruikersreferenties:
mysql -u test_user -p
Let op de -pvlag in deze opdracht, die je zal vragen om het wachtwoord dat wordt gebruikt bij het aanmaken van de test_user gebruiker. Nadat je hebt aangemeld bij de MySQL-console, bevestigt je dat je toegang heeft tot de test_database database:
SHOW DATABASES;
Dit geeft je de output van welke databases deze gebruiker mag inzien/wijzigen.
Vervolgens maken we een testtabel met de naam todo_list . Voer vanuit de MySQL-console de volgende instructie uit:
CREATE TABLE test_database.todo_list (item_id INT AUTO_INCREMENT, content VARCHAR(255), PRIMARY KEY(item_id));
Voeg een paar rijen inhoud in de testtabel in. Misschien wil je de volgende opdracht een paar keer herhalen met verschillende waarden:
INSERT INTO test_database.todo_list (content) VALUES ("Mijn eerste belangrijke item");
Voer het volgende uit om te bevestigen dat de gegevens met succes zijn opgeslagen in je tabel:
SELECT * FROM test_database.todo_list;
Je ziet de output met inhoud van je database
Nadat je hebt bevestigd dat je geldige gegevens in je testtabel hebt, kun je de MySQL-console verlaten:
exit
index.php maken
Nu kun je het PHP-script maken dat verbinding maakt met MySQL en naar je inhoud vraagt. Maak een nieuw PHP-bestand in je aangepaste webhoofddirectory met behulp van je favoriete editor. We gebruiken nanodaarvoor:
nano /var/www/noorderpoort/todo_list.php
Het volgende PHP-script maakt verbinding met de MySQL-database en vraagt om de inhoud van de tabel todo_list , waarbij de resultaten in een lijst worden weergegeven. Als er een probleem is met de databaseverbinding, wordt er een uitzondering gegenereerd.
Kopieer deze inhoud naar uw todo_list.phpscript:
/var/www/noorderpoort/todo_list.php
<?php
$user = "test_user";
$password = "password";
$database = "test_database";
$table = "todo_list";
try {
$db = new PDO("mysql:host=localhost;dbname=$database", $user, $password);
echo "<h2>TODO</h2><ol>";
foreach($db->query("SELECT content FROM $table") as $row) {
echo "<li>" . $row['content'] . "</li>";
}
echo "</ol>";
} catch (PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
?>
Sla het bestand op en sluit het als je klaar bent met bewerken.
Je kunt deze pagina nu openen in je webbrowser door naar de domeinnaam of het openbare IP-adres dat voor je website is geconfigureerd, te bezoeken, gevolgd door /todo_list.php:
http://your_domain_or_IP/todo_list.php
Je zou een pagina als deze moeten zien met de inhoud die in je testtabel hebt ingevoegd.
Dat betekent dat je PHP-omgeving klaar is om verbinding te maken en te communiceren met je MySQL-server.
Snapshot maken
Maak van je omgeving een snapshot als deze helemaal gereed is.
Opdracht LAMP
De opdracht voor het maken van een LAMP-server staat gereed op ItsLearning. Deze maken, goed lezen hoe de domeinnamen en wat de databasenaam is. Kijk goed welk deel je moet vervangen voor andere namen, enz.
Les 4: SAMBA
Deze les gaan we aan de slag met Samba en shares. Samba-servers worden gebruikt om shares te maken voor verschillende gebruikers en als data-server.
Voorbereiding:
- Zorg ervoor dat alle AMP processen uit voorgaande les gestopt zijn.
- AMP met APT verwijderen
- Controleren of de map /var/www leeg is
- Zoek naar AMP processen op de server en "kill" deze
- deny AMP in UFW
of
- Ga terug naar je snapshot (2) dat de ubuntu-server helemaal basis gereed was. (Aanbevolen!)
Samba installeren
Laten we beginnen met het installeren van Samba met behulp van het pakketbeheersysteem van Ubuntu.
Voordat we nieuwe pakketten gaan installeren, moeten we de lokale pakketindex bijwerken met de meest up-to-date versies van de Ubuntu-repositories:
sudo apt update
Installeer vervolgens Samba:
sudo apt install samba
Dit commando zal zowel de Samba-server smbdals de Samba NetBIOS-server installeren en starten nmbd. nmbdis niet vereist voor deze tutorial, dus uit veiligheidsoverwegingen kun je deze stoppen en uitschakelen met systemctl:
sudo systemctl stop nmbd.service
sudo systemctl disable nmbd.service
De sudo systemctl disable nmbd.serviceopdracht produceert de volgende uitvoer wanneer deze wordt uitgevoerd:
Deze uitvoer geeft aan dat omdat nmbdhet geen native systemdbeheerconfiguratie heeft, het wordt uitgeschakeld door het oudere SysV-init-systeem.
Om beveiligingsproblemen te vermijden die kunnen ontstaan door het draaien van een niet-geconfigureerde, netwerkgeschikte service, laten we de Samba-server stoppen totdat de configuratiedetails aanwezig zijn:
sudo systemctl stop smbd.service
Samba is nu geïnstalleerd en klaar om geconfigureerd te worden.
Samba configuratie
Laten we definiëren hoe de Samba-server zich zal gedragen door het configuratiebestand op /etc/samba/smb.conf. Dit bestand bestaat uit twee delen: een [global]sectie en een [shares]sectie. De [global]sectie configureert het gedrag van de Samba-server, en de [shares]secties configureren de bestandsshares. Laten we beginnen met het stellen van richtlijnen in de [global]sectie.
In plaats van /etc/samba/smb.confrechtstreeks te bewerken, hernoemt u het naar smb.conf.originalen maakt u een nieuw bestand met de naam smb.conf:
sudo mv /etc/samba/smb.conf /etc/samba/smb.conf.orig
/etc/samba/smb.confLaten we voor het bewerken eerst de beschikbare interfaces controleren om Samba te vertellen welke het moet herkennen. Typ het volgende:
ip link
Deze uitvoer geeft aan dat lodit de loopback-interface is en dat ens33dit de externe netwerkinterface is, hoewel je externe interface kan verschillen. Let op beide: je neemt ze op bij de interfacesrichtlijn in het [global]gedeelte van het smb.confbestand.
Laten we beginnen met het bewerken van dit bestand met nanoof je favoriete editor:
sudo nano /etc/samba/smb.conf
De [global]sectie van dit bestand definieert de naam, de rol en andere details van de server, inclusief netwerkinterfaces:
Deze richtlijnen specificeren het volgende:
server string- Dit is de identificerende informatie die tijdens verbindingen aan gebruikers wordt verstrekt. Je kunt samba_serverof een andere naam gebruiken die je server identificeert. In deze tutorial zul je de string zien samba.noorderpoort.comom de Samba-share voor de organisatie Noorderpoort aan te duiden .server role- Dit bepaalt welk type Samba-server zal worden aangemaakt. In dit geval is het een standalone server, dwz een bestandsshare. Andere servertypen zijn onder meer domeinlidservers en domeincontrollers.interfaces- Dit zijn de netwerkinterfaces waaraan Samba zal binden. lois de loopback-interface (127.0.0.1) en is vereist. U moet ook de externe netwerkinterface opnemen die u eerder hebt uitgevoerd. Dit is meestal ens33.bind interfaces only- Dit zorgt ervoor dat Samba alleen bindt aan de interfaces die op de interfacesregel worden vermeld. Als veiligheidsmaatregel zorgt dit ervoor dat Samba pakketten negeert die niet overeenkomen met de gespecificeerde interfaces.disable netbios- Hierdoor worden alle NetBIOS-functies uitgeschakeld die niet nodig zijn in een zelfstandige server. Dit vereenvoudigt het omzettingsproces van de servernaam en het transport van SMB-verkeer.smb ports- Dit stelt de poort in waarop Samba zal luisteren. Poort 445is de standaardpoort voor Samba.log file - Dit stelt de naam en locatie van het logbestand van Samba in.max log size- Dit stelt een limiet in voor de grootte van het logbestand. Het vermelde nummer is in bytes en is gelijk aan 10 MB. Enkele dingen om in gedachten te houden bij het instellen van deze groottelimiet: Wanneer deze is bereikt, zal Samba een nieuw logbestand genereren en de oude inhoud naar een duplicaat met een .oldextensie verplaatsen . Als de limiet opnieuw wordt overschreden, wordt het bestaande .oldbestand vernietigd. Dit voorkomt dat schijf- / partitieruimte wordt overweldigd door de inhoud van een enkel logbestand. Daarom moet u een bestandsgrootte definiëren die logisch is voor uw systeembronnen.
[global]
server string = samba.patrick.com
server role = standalone server
interfaces = lo ens33
bind interfaces only = yes
disable netbios = yes
smb ports = 445
log file = /var/log/samba/smb.log
max log size = 10000
Sla het bestand op en sluit het als je klaar bent met het maken het aanpassen.
Elke keer dat je smb.confbewerkt, moet je het Samba-hulpprogramma uitvoeren testparmom te controleren of er geen syntaxisfouten zijn:
testparm
Het uitvoeren van de testparmopdracht op het smb.confbestand levert de volgende uitvoer op:
Als er testparmrapporten zijn Loaded services file OK., zijn er geen syntaxisfouten waardoor de Samba-server niet meer opstart.
Het configureren van de [global]sectie is alles wat nodig is om de Samba-server te starten. De functionaliteit zal echter beperkt zijn zonder deelconfiguraties. Een share bestaat uit twee delen, een gebruiker en een directory, die beide moeten worden gemaakt en geconfigureerd om inloggen en testen mogelijk te maken.
Gebruikers aanmaken
In deze stap maken we gebruikers die toegang hebben tot de shares. Ze hebben toegang nodig als Samba- en systeemgebruikers om zich te authenticeren bij de Samba-server wanneer ze inloggen en lezen en schrijven naar het bestandssysteem.
In het hypothetische bedrijf Noorderpoort.com zijn er 1 werknemer die moet worden toegevoegd aan de Samba-server en aangemaakt als gebruiker op het Linux-systeem: david. Naast deze gebruiker zal er een admin gebruiker zijn die toegang heeft tot de persoonlijke shares en deze kan beheren. Deze gebruiker zal ook de gemeenschappelijke gedeelde mappen bezitten waartoe iedereen toegang heeft.
De eerste stap bij het toevoegen van systeemgebruikers is het maken van homedirectory's voor elk van hen. In plaats van de standaard homedirectory's te gebruiken /home/user, zullen de Samba-directory's en gegevens zich in /samba/. Door Samba-gegevens op één locatie te bewaren en gescheiden van andere gebruikersgegevens, worden toekomstige beheertaken, zoals back-ups, eenvoudiger.
De eerste stap is het maken van de directory waar de Samba-gegevens worden opgeslagen, in de root van het bestandssysteem. Deze map zal worden genoemd /samba/, en het groepseigendom zal worden ingesteld op sambashareeen groep die is gemaakt toen u Samba installeerde.
Voer de volgende opdrachten uit om de /samba/directory te maken en stel het groepseigendom in op sambashare:
sudo mkdir /samba/
sudo chown :sambashare /samba/
Maak vervolgens de homedirectory van David onder de /samba/directory:
sudo mkdir /samba/david
Voeg nu David toe als systeemgebruiker met de volgende opdracht:
sudo adduser --home /samba/david --no-create-home --shell /usr/sbin/nologin --ingroup sambashare david
De opties doen het volgende:
--home - Dit stelt de locatie van de homedirectory van de gebruiker in.--no-create-home- Dit stopt de adduseropdracht om de homedirectory van David te maken . Als het systeem deze map zou maken, zou deze worden gevuld met configuratiebestanden zoals .bash_historydie niet nodig zijn voor de huidige installatie.--shell- Dit stelt in welke shell- david wordt toegewezen wanneer hij inlogt via SSH. Een SSH-login is niet nodig voor toegang tot een Samba-share; als je dit instelt, /usr/sbin/nologinworden SSH-logins uitgeschakeld.--in-group sambashare Dit voegt de gebruiker toe aan de sambasharegroep, waardoor ze lees- en schrijftoegang krijgen tot hun eigen shares en tot de gemeenschappelijke share.
Je wordt om een wachtwoord gevraagd wanneer je deze opdracht uitvoert. Kies een uniek, niet-woordenboekgebaseerd wachtwoord van 10 tekens of meer.
Nu de systeemgebruiker David bestaat, kun je het eigendom en de rechten instellen voor zijn Samba-homedirectory:
sudo chown david:sambashare /samba/david/
sudo chmod 2770 /samba/david/
Als je de machtigingen van de map instelt op 2770, zullen nieuwe bestanden of mappen die worden aangemaakt /samba/david/, het groepseigendom van de bovenliggende map overnemen in plaats van de primaire groep van de gebruiker die het bestand of de map heeft gemaakt. Dit betekent bijvoorbeeld dat als de admin gebruiker een nieuwe directory in davids share zou maken, David deze zou kunnen lezen en ernaar zou kunnen schrijven.
Voeg vervolgens david toe aan de Samba-server. Samba houdt zijn eigen database met gebruikers en wachtwoorden bij, die het gebruikt om aanmeldingen te verifiëren. Om in te loggen, moeten alle gebruikers aan de Samba-server zijn toegevoegd en ingeschakeld. Voer de volgende smbpasswdopdrachten uit om beide taken uit te voeren:
sudo smbpasswd -a david
sudo smbpasswd -e david
De hier gebruikte opties doen het volgende:
-a - Dit voegt de gebruiker toe aan de Samba-server zonder deze in te schakelen.-e - Dit maakt een eerder toegevoegde gebruiker mogelijk.
Het wachtwoord dat je hier invoert, wordt gebruikt om toegang te krijgen tot de Samba-share en kan verschillen van het systeemwachtwoord.
De gebruiker David bestaat nu als een systeemgebruiker zonder de mogelijkheid om SSH in de server te plaatsen. Hij heeft een homedirectory op /samba/david, en is geregistreerd en ingeschakeld als Samba-gebruiker.
Herhaal dit proces voor elke Samba-gebruiker die je nog toe wilt voegen.
Om de admin gebruiker te maken, voer je de volgende opdrachten uit en wijzig je de homedirectory in /samba/everyone/:
sudo mkdir /samba/everyone
sudo adduser --home /samba/everyone --no-create-home --shell /usr/sbin/nologin --ingroup sambashare admin
sudo chown admin:sambashare /samba/everyone/
sudo chmod 2770 /samba/everyone/
sudo smbpasswd -a admin
sudo smbpasswd -e admin
Naast het aanmaken van de admin gebruiker, maken we een groep genaamd admins om het beheer van de server gemakkelijker te maken. Met lees- en schrijfrechten voor elke share, kan deze groep het toevoegen en verwijderen van gebruikers vereenvoudigen. Als individuele gebruikers bijvoorbeeld fungeren als admin gebruikers en vervolgens de organisatie verlaten, moeten ze afzonderlijk van elke share worden verwijderd. Nieuwe beheerders moeten ook handmatig aan elke share worden toegevoegd. Door een beheerdersgroep aan te maken en deze groep lees- en schrijftoegang te geven tot de gedeelde mappen, hoeft u slechts één opdracht toe te voegen en te verwijderen.
Voer de volgende commando's om een nieuwe groep te maken met de naam admins en voeg de gebruiker admin naar deze groep:
sudo groupadd admins
sudo usermod -G admins admin
De systeemconfiguraties zijn nu voltooid, waarbij de gebruikers van de organisatie Noorderpoort.com zijn ingesteld als systeem- en Samba-gebruikers. Laten we verder gaan met het configureren van de Samba-server zodat deze gebruikers toegang hebben tot hun gedeelde mappen.
Samba-shares configuratie
Elke share heeft zijn eigen sectie in het hoofdconfiguratiebestand van Samba /etc/samba/smb.conf, volgens de globale parameters. Deze secties zullen bepalen hoe elke share zal werken.
Gebruik de nanoteksteditor opnieuw om dit bestand te openen en te bewerken:
sudo nano /etc/samba/smb.conf
Het volgende configuratieblok definieert de persoonlijke share van elke gebruiker:
/etc/samba/smb.conf
...
[share_name]
path =
browseable =
read only =
force create mode =
force directory mode =
valid users =
Deze opties zijn:
share_name - Dit is de naam van de share die u gaat gebruiken bij het inloggen.path - Dit is het absolute pad naar de share in het bestandssysteem.browsable- Dit stelt in of andere gebruikers de share al dan niet kunnen zien. Door deze optie in te schakelen, kunnen alleen andere gebruikers van de Samba-server het bestaan van de share zien. Het verleent geen lees- of schrijfrechten.read only- Dit stelt in of valid usersze naar de gedeelde map kunnen schrijven.force create mode - Dit dwingt de machtigingen af voor elk bestand dat naar de share is geschreven.force directory mode - Dit dwingt de machtigingen af voor elke map die in de share is gemaakt.valid users- Dit is een lijst met de gebruikers die toegang hebben tot de share. Deze instelling kan gebruikersnamen of systeemgroepen, zoals beheerders, bevatten. Groepen moeten @vooraan staan, bijv @admins.
Voeg het volgende share-configuratieblok toe voor david, waarin zijn homedirectory wordt gedefinieerd, de machtigingen voor het groepseigendom van deze directory en de gebruikers die toegang moeten hebben tot zijn share:
/etc/samba/smb.conf
[david]
path = /samba/david
browseable = no
read only = no
force create mode = 0660
force directory mode = 2770
valid users = david @admins
Merk op dat de directory-machtigingen het groepseigendom instellen op dat van de bovenliggende directory.
Maak een deelblok voor je overige gebruikers, zoals die van David.
Het [everyone]aandeel zal verschillen van de anderen in beide [name], path, valid users, en browsableopties, en ziet er als volgt uit:
/etc/samba/smb.conf
...
[everyone]
path = /samba/everyone
browseable = yes
read only = no
force create mode = 0660
force directory mode = 2770
valid users = @sambashare @admins
Door de sambasharegroep lees- en schrijftoegang tot de gedeelde map te geven, krijgen alle gebruikers toegang tot de gedeelde map, aangezien ze aan deze groep zijn toegevoegd toen ze werden gemaakt.
Sla het bestand op en sluit het als je klaar bent met bewerken.
Test de configuratie opnieuw:
testparm
Nu de configuratiecontrole is voltooid, laten we de Samba-server starten met systemctl:
sudo systemctl start smbd.service
De Samba-server draait nu en is klaar om aanmeldingen te accepteren. De volgende stap is om in te loggen op de Samba-server om te testen of deze werkt zoals verwacht.
UFW!
Voeg Samba toe aan UFW.
sudo ufw app list
sudo ufw allow Samba
Inloggen op de Samba-server
Linux - CLI
Je kunt een tool gebruiken smbclientom toegang te krijgen tot Samba vanaf de CLI. Dit pakket wordt niet standaard meegeleverd op de meeste Linux-distributies, dus je moet het installeren met uw lokale pakketbeheerder.
Op de Ubuntu desktop!!!
Installeer de smbclientmet de volgende opdracht:
sudo apt update
sudo apt install smbclient
smbclient gebruikt het volgende formaat om toegang te krijgen tot Samba-shares:
smbclient //Server_ip/share -U username
Je kunt het IP-adres van je server of de hostnaam die je hebt opgegeven gebruiken /etc/samba/smb.confom toegang te krijgen tot de share. In dit voorbeeld wordt de hostnaam gebruikt samba.noorderpoort.comom toegang te krijgen tot de share van David op de Samba-server die je in de vorige stappen hebt gemaakt:
smbclient //Server_IP/david -U david
Als David toegang wil tot de gemeenschappelijke share ( everyone), wijzig je de opdracht in:
smbclient //Server_IP/everyone -U david
Na het uitvoeren van de smbclientopdracht, wordt je om het Samba-wachtwoord gevraagd en ingelogd op een opdrachtregelinterface die doet denken aan de FTP-tekstinterface:
smb: \>
Deze interface is vooral handig voor het testen van gebruikersnamen en wachtwoorden en voor lees- en schrijftoegang. Je kunt bijvoorbeeld een directory maken en de inhoud ervan als volgt weergeven:
mkdir test
Je zou de volgende output moeten zien:
Type exit om Samba op de CLI te verlaten.
Het beheren van gegevens in een share is vaak eenvoudiger met een GUI-tool. De volgende sectie zal kijken naar de ingebouwde GUI-tools voor KDE.
Linux - GUI
Ga op de Ubuntu-desktop naar files en klik op Other Locations.
Typ bij Connect to Server
smb://192.168.182.130/david/
en klik op connect
Voer de inlog gegevens van David in en je hebt verbinding met de Samba-share.
Je kunt nu de Samba-share gebruiken alsof het een lokale map is om bestanden en mappen te kopiëren, verwijderen en hernoemen. De share zal ook verschijnen als een permanente bladwijzer in de netwerklocaties .
Snapshot maken
Maak een snapshot van je Samba-server.
Opdracht Samba
De opdracht voor Samba staat gereed op ItsLearning. Goed kijken naar de naamgeving van de shares en gebruikers, deze kunnen afwijken van dit voorbeeld.
Les 5: MySQL
Deze les gaan we aan de slag met een database-server. Wij hebben gekozen voor MySQL, omdat dit een zeer populaire database applicatie is en veel wordt gebruikt.
Voorbereiding:
- Zorg ervoor dat alle Samba processen uit voorgaande les gestopt zijn.
- Samba met APT verwijderen
- Controleren of de map /samba/ leeg is
- Zoek naar Samba processen op de server en "kill" deze
- deny Samba in UFW
of
- Ga terug naar je snapshot (2) dat de ubuntu-server helemaal basis gereed was. (Aanbevolen!)
MySQL installeren
Op Ubuntu 20.04 kun je MySQL installeren met behulp van de APT-pakketrepository. De versie kan verschillen wat standaard in Ubuntu-pakket is opgenomen.
Om het te installeren, werk je de pakketindex op je server bij als je dit niet recentelijk hebt gedaan:
sudo apt update
Installeer vervolgens het mysql-serverpakket:
sudo apt install mysql-server
Hierdoor wordt MySQL geïnstalleerd, maar wordt je niet gevraagd een wachtwoord in te stellen of andere configuratiewijzigingen aan te brengen. Omdat dit je installatie van MySQL onveilig maakt, zullen we dit hierna aanpakken.
MySQL configureren
Voor nieuwe installaties van MySQL, wil je het meegeleverde beveiligingsscript van de DBMS uitvoeren. Dit script verandert enkele van de minder veilige standaardopties voor zaken als root-logins op afstand en voorbeeldgebruikers.
Voer het beveiligingsscript uit met sudo:
sudo mysql_secure_installation
Dit zal je door een reeks prompts leiden waar je enkele wijzigingen kunt aanbrengen in de beveiligingsopties van je MySQL-installatie. De eerste prompt zal je vragen of je de Validate Password Plugin wilt instellen, die kan worden gebruikt om de wachtwoordsterkte van nieuwe MySQL-gebruikers te testen voordat ze als geldig worden beschouwd.
Als je ervoor kiest om de plug-in Validate Password in te stellen, moet elke MySQL-gebruiker die je aanmaakt en zich verifieert met een wachtwoord, een wachtwoord hebben dat voldoet aan het beleid dat je selecteert. Het sterkste beleidsniveau - dat je kunt selecteren door in te voeren 2- vereist dat wachtwoorden minstens acht tekens lang zijn en een combinatie van hoofdletters, kleine letters, numerieke en speciale tekens bevatten.
Ongeacht of je ervoor kiest om de Validate Password Plugin in te stellen, de volgende prompt is om een wachtwoord in te stellen voor de MySQL- rootgebruiker. Voer een veilig wachtwoord naar keuze in en bevestig het.
Merk op dat, hoewel je een wachtwoord hebt ingesteld voor de root MySQL-gebruiker, deze gebruiker momenteel niet is geconfigureerd om te verifiëren met een wachtwoord bij het verbinden met de MySQL-shell.
Als je de plug-in Validate Password hebt gebruikt, ontvang je feedback over de sterkte van je nieuwe wachtwoord. Vervolgens vraagt het script of je door wilt gaan met het wachtwoord dat je zojuist hebt ingevoerd of dat je een nieuw wachtwoord wilt invoeren. Ervan uitgaande dat je tevreden bent met de sterkte van het wachtwoord dat je zojuist hebt ingevoerd, voer je een Yom door te gaan met het script.
Van daaruit kun je op Yen vervolgens drukken ENTERom de standaardinstellingen voor alle volgende vragen te accepteren. Hiermee worden enkele anonieme gebruikers en de testdatabase verwijderd, worden root-aanmeldingen op afstand uitgeschakeld en worden deze nieuwe regels geladen zodat MySQL onmiddellijk de wijzigingen respecteert die je hebt aangebracht.
Zodra het script is voltooid, wordt je MySQL-installatie beveiligd. Je kunt nu doorgaan met het maken van een speciale databasegebruiker met de MySQL-client.
Een Dedicated gebruiker en rechten toekennen
Na installatie maakt MySQL een rootgebruikersaccount aan die je kunt gebruiken om je database te beheren. Deze gebruiker heeft volledige privileges over de MySQL-server, wat betekent dat hij volledige controle heeft over elke database, tabel, gebruiker, enzovoort. Daarom is het het beste om dit account niet buiten administratieve functies te gebruiken. In deze stap wordt beschreven hoe je de MySQL- rootgebruiker gebruikt om een nieuw gebruikersaccount aan te maken en deze rechten te verlenen.
sudo mysql
Opmerking: als je MySQL samen met een andere tutorial hebt geïnstalleerd en wachtwoordverificatie voor root hebt ingeschakeld , moet je een ander commando gebruiken om toegang te krijgen tot de MySQL-shell. Het volgende zal uw MySQL-client uitvoeren met normale gebruikersrechten, en je krijgt alleen beheerdersrechten binnen de database door te verifiëren:
sudo mysql -u root -p
Zodra je toegang hebt tot de MySQL-prompt, kun je een nieuwe gebruiker aanmaken met een CREATE USERinstructie. Deze volgen deze algemene syntaxis:
CREATE USER 'username'@'host' IDENTIFIED WITH authentication_plugin BY 'password';
Daarna CREATE USERspecificeert je een gebruikersnaam. Dit wordt onmiddellijk gevolgd door een @teken en vervolgens de hostnaam waarmee deze gebruiker verbinding zal maken. Als je alleen van plan bent om deze gebruiker lokaal te benaderen vanaf je Ubuntu-server, kun je specificeren localhost. Het is niet altijd nodig om zowel de gebruikersnaam als de host tussen enkele aanhalingstekens te plaatsen, maar dit kan helpen om fouten te voorkomen.
Voer de volgende opdracht uit om een gebruiker te maken waarmee wordt geverifieerd caching_sha2_password. Zorg ervoor dat je lindauw gebruikersnaam en passwordeen sterk wachtwoord naar keuze wijzigt :
CREATE USER 'linda'@'localhost' IDENTIFIED BY 'password';
Opmerking: er is een bekend probleem met sommige versies van PHP dat problemen veroorzaakt met caching_sha2_password. Als je van plan bent om deze database te gebruiken met een PHP-applicatie, bijvoorbeeld phpMyAdmin, wil je misschien een gebruiker aanmaken die zich zal authenticeren met de oudere, maar nog steeds veilige mysql_native_passwordplug-in:
CREATE USER 'linda'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
Als je het niet zeker weet, kun je altijd een gebruiker maken die zich aanmeldt met caching_sha2_pluginen ALTERdeze later met deze opdracht:
ALTER USER 'linda'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
Nadat je de nieuwe gebruiker hebt aangemaakt, kun je deze de juiste rechten verlenen. De algemene syntaxis voor het toekennen van gebruikersrechten is als volgt:
GRANT PRIVILEGE ON database.table TO 'username'@'host';
De PRIVILEGEwaarde in de syntaxis van dit voorbeeld definieert welke acties de gebruiker mag uitvoeren op de opgegeven databaseen table. Je kunt in één opdracht meerdere rechten toekennen aan dezelfde gebruiker door ze te scheiden met een komma. Je kunt een gebruiker ook globaal privileges verlenen door asterisks ( *) in te voeren in plaats van de database- en tabelnamen. In SQL zijn asterisken speciale tekens die worden gebruikt om "alle" databases of tabellen weer te geven.
Ter illustratie, de volgende opdracht geeft een gebruiker wereldwijde rechten om CREATE, ALTERen DROPdatabases, tabellen en gebruikers, evenals de bevoegdheid om INSERT, UPDATEen DELETEgegevens van een tabel op de server. Het geeft de gebruiker ook de mogelijkheid om gegevens op te vragen SELECT, externe sleutels te maken met het REFERENCESsleutelwoord en FLUSHbewerkingen uit te voeren met het RELOADrecht. Geef gebruikers echter alleen de rechten die ze nodig hebben, dus voel je vrij om de rechten van je eigen gebruikers aan te passen als dat nodig is.
Voer deze GRANTinstructie uit en vervang deze lindadoor je eigen MySQL-gebruikersnaam om je gebruiker deze rechten te verlenen:
GRANT CREATE, ALTER, DROP, INSERT, UPDATE, DELETE, SELECT, REFERENCES, RELOAD on *.* TO 'linda'@'localhost' WITH GRANT OPTION;
Waarschuwing : sommige beheerders willen misschien hun MySQL-gebruiker het ALL PRIVILEGESprivilege geven, waardoor ze brede superuser-privileges krijgen die vergelijkbaar zijn met de privileges van de root gebruiker, zoals:
GRANT ALL PRIVILEGES ON *.* TO 'linda'@'localhost' WITH GRANT OPTION;
Dergelijke brede privileges moeten niet te makkelijk worden toegekend, aangezien iedereen met toegang tot deze MySQL-gebruiker volledige controle heeft over elke database op de server.
Hierna is het een goede gewoonte om de FLUSH PRIVILEGESopdracht uit te voeren. Zo zal er geen geheugen dat de server in de cache als een resultaat van het voorgaande CREATE USERen GRANTverklaringen:
FLUSH PRIVILEGES;
Vervolgens kunt je de MySQL-client verlaten:
exit
Om in de toekomst in te loggen als je nieuwe MySQL-gebruiker, gebruik je een commando zoals het volgende:
mysql -u linda -p
De -pvlag zorgt ervoor dat de MySQL-client je vraagt om het wachtwoord van je MySQL-gebruiker om te verifiëren.
MySQL testen
Ongeacht hoe je het hebt geïnstalleerd, MySQL had automatisch moeten worden gestart. Controleer de status om dit te testen.
sudo systemctl status mysql.service
Als MySQL niet actief is, kun je het starten met sudo systemctl start mysql.
Voor een extra controle kun je proberen verbinding te maken met de database met behulp van de mysqladmintool, een client waarmee je beheeropdrachten kunt uitvoeren. Dit commando zegt bijvoorbeeld om verbinding te maken als een MySQL-gebruiker met de naam linda, om een wachtwoord te vragen en de versie te retourneren. Zorg ervoor dat je de naam van je dedicated MySQL-gebruiker wijzigt en voer het wachtwoord van die gebruiker in wanneer daarom wordt gevraagd:
sudo mysqladmin -p -u linda version
Dit betekent dat MySQL actief is en gereed voor gebruik.
MySQL database maken
Databases zijn een belangrijk onderdeel van veel websites en applicaties, en vormen de kern van de manier waarop gegevens worden opgeslagen en uitgewisseld via internet. Een van de belangrijkste aspecten van databasebeheer is het ophalen van gegevens uit een database, of dit nu op ad-hoc basis is of als onderdeel van een proces dat in een applicatie is gecodeerd. Er zijn verschillende manieren om informatie uit een database op te halen, maar een van de meest gebruikte methoden is het indienen van vragen via de opdrachtregel.
In relationele databasebeheersystemen is een query elke opdracht die wordt gebruikt om gegevens uit een tabel op te halen. In Structured Query Language (SQL) worden queries bijna altijd gedaan met de SELECTinstructie.
Voordat we kunnen beginnen met het maken van query's in SQL, zullen we eerst een database en een paar tabellen maken en deze tabellen vervolgens vullen met enkele voorbeeldgegevens. Hierdoor kun je wat praktische ervaring opdoen wanneer je later begint met het maken van queries.
Open om te beginnen een MySQL-prompt als je MySQL- rootgebruiker :
sudo mysql
Opmerking: mogelijk heb je de rootgebruiker geconfigureerd om te verifiëren met een wachtwoord. In dit geval maak je verbinding met de MySQL-prompt met de volgende opdracht:
mysql -u root -p
Maak vervolgens de database door:
CREATE DATABASE `verjaardag`;
Selecteer vervolgens deze database door te typen:
USE verjaardag;
Maak vervolgens twee tabellen binnen deze database. We gebruiken de eerste tabel om de records van je vrienden op de bowlingbaan bij te houden. Met het volgende commando wordt een tabel gemaakt tourneysmet kolommen voor nameelk van je vrienden, het aantal toernooien dat ze hebben gewonnen ( wins), hun all-time bestscore en welke maat bowlingschoen ze dragen ( size):
CREATE TABLE tourneys (name varchar(30), wins real, best real, size real);
Nadat u de CREATE TABLEopdracht hebt uitgevoerd krijg je de melding:
Query OK
Vul de tourneystabel met enkele voorbeeldgegevens:
INSERT INTO tourneys (name, wins, best, size) VALUES ('Koos', '7', '245', '8.5'), ('Richard', '4', '283', '9'), ('Martijn', '9', '266', '7'), ('Wilma', '2', '197', '7.5'), ('Annet', '13', '273', '8');
Je ontvangt een output als deze:
Output
Query OK, 5 rows affected (0.01 sec)
Maak daarna een nieuwe tabel in dezelfde database die we zullen gebruiken om informatie op te slaan over de favoriete verjaardagsmaaltijden van je vrienden. Met de volgende opdracht maak je een tabel met de naam dinnersmet kolommen voor name je vrienden, hun birthdate, hun favoriet entree, hun favoriete sidegerecht en hun favoriet dessert:
CREATE TABLE dinners (name varchar(30), birthdate date, entree varchar(30), side varchar(30), dessert varchar(30));
Op dezelfde manier ontvang je voor deze tabel feedback waarin wordt bevestigd dat de opdracht met succes is uitgevoerd:
Query OK, 0 rows affected (0.01 sec)
Vul deze tabel ook met enkele voorbeeldgegevens:
INSERT INTO dinners (name, birthdate, entree, side, dessert) VALUES ('Hans', '1946-01-19', 'steak', 'salad', 'cake'), ('Linda', '1938-01-25', 'chicken', 'fries', 'ice cream'), ('Helma', '1941-02-18', 'tofu', 'fries', 'cake'), ('Daan', '1948-12-25', 'tofu', 'salad', 'ice cream'), ('Tom', '1944-05-28', 'steak', 'fries', 'ice cream');
Query OK, 5 rows affected (0.00 sec)
Zodra die opdracht met succes is voltooid, bent je klaar met het opzetten van je database. Vervolgens bespreken we de basisopdrachtstructuur van SELECTquery's.
Inzicht in SELECT query's
Zoals vermeld in de inleiding, beginnen SQL-query's bijna altijd met de SELECTinstructie. SELECTwordt gebruikt in query's om aan te geven welke kolommen uit een tabel in de resultatenset moeten worden geretourneerd. Query's bevatten ook bijna altijd FROM, wat wordt gebruikt om aan te geven in welke tabel de instructie een query zal uitvoeren.
Over het algemeen volgen SQL-query's deze syntaxis:
SELECT column_to_select FROM table_to_select WHERE certain_conditions_apply;
Bij wijze van voorbeeld zal de volgende instructie de volledige namekolom uit de dinnerstabel retourneren :
SELECT name FROM dinners;
Je kunt meerdere kolommen uit dezelfde tabel selecteren door hun namen als volgt met een komma te scheiden:
SELECT name, birthdate FROM dinners;
In plaats van een specifieke kolom of set kolommen een naam te geven, kun je de SELECToperator volgen met een asterisk ( *) die dient als tijdelijke aanduiding voor alle kolommen in een tabel. De volgende opdracht retourneert elke kolom uit de tourneystabel:
SELECT * FROM tourneys;
WHEREwordt gebruikt in query's om records te filteren die aan een bepaalde voorwaarde voldoen, en alle rijen die niet aan die voorwaarde voldoen, worden uit het resultaat verwijderd. Een WHEREclausule volgt doorgaans deze syntaxis:
. . . WHERE column_name comparison_operator value
De vergelijkingsoperator in een WHEREclausule definieert hoe de opgegeven kolom moet worden vergeleken met de waarde. Hier zijn enkele veelgebruikte SQL-vergelijkingsoperatoren:
| Operator |
Wat het doet |
= |
test voor gelijkheid |
!= |
test voor ongelijkheid |
< |
test voor minder dan |
> |
test voor groter dan |
<= |
test voor kleiner dan of gelijk aan |
>= |
test voor groter dan of gelijk aan |
BETWEEN |
test of een waarde binnen een bepaald bereik ligt |
IN |
test of de waarde van een rij is opgenomen in een set gespecificeerde waarden |
EXISTS |
test of er rijen bestaan, gegeven de opgegeven voorwaarden |
LIKE |
test of een waarde overeenkomt met een opgegeven string |
IS NULL |
test voor NULLwaarden |
IS NOT NULL |
test voor alle andere waarden dan NULL |
Als je bijvoorbeeld de schoenmaat van Koos wilt vinden, kun je de volgende zoekopdracht gebruiken:
SELECT size FROM tourneys WHERE name = 'Koos';
Probeer zelf eens uit meerdere tabellen gegevens naar voren te krijgen die in de tabellen zitten met bovenstaande operators.
Query's geven is een van de meest uitgevoerde taken op het gebied van databasebeheer. Er zijn applicaties zoals phpMyAdmin waarmee je query's kunt visualiseren, maar op de achtergrond is er altijd een database dat ergens op een server draait.
Snapshot maken
Maak een snapshot van je net gemaakte MySQL server.
Opdracht MySQL
De opdracht voor MySQL-server staat op ItsLearning. LET OP!! de naamgeving van je database en tabellen kan verschillen. Als de opdracht gereed is, deze inleveren op ItsLearning.
Les 6: Docker
Docker wordt gebruikt om softwarepakketten uit te voeren die 'containers' worden genoemd. Containers zijn geïsoleerd van elkaar en bundelen hun eigen applicatie, tools, bibliotheken en configuratiebestanden; ze kunnen met elkaar communiceren via goed gedefinieerde kanalen. Alle containers worden uitgevoerd door een enkele kernel van het besturingssysteem en zijn dus lichter dan virtuele machines. Containers worden gemaakt van 'images' die hun precieze inhoud specificeren. Images worden vaak gemaakt door standaard images te combineren en te wijzigen die zijn gedownload van openbare archieven.
Voorbereiding:
- Zorg ervoor dat alle MySQL processen uit voorgaande les gestopt zijn.
- MySQL met APT verwijderen
- Zoek naar MySQL processen op de server en "kill" deze
- deny MySQL in UFW
of
- Ga terug naar je snapshot (2) dat de ubuntu-server helemaal basis gereed was. (Aanbevolen!)
Docker installeren
Het Docker-installatiepakket dat beschikbaar is in de officiële Ubuntu-repository is mogelijk niet de laatste versie. Om ervoor te zorgen dat we de nieuwste versie krijgen, installeren we Docker vanuit de officiële Docker-repository. Om dat te doen, zullen we een nieuwe pakketbron toevoegen, de GPG-sleutel van Docker toevoegen om ervoor te zorgen dat de downloads geldig zijn, en vervolgens het pakket installeren.
Werk eerst uw bestaande lijst met pakketten bij:
sudo apt update
Installeer vervolgens een paar vereiste pakketten waarmee aptje pakketten via HTTPS kunt gebruiken:
sudo apt install apt-transport-https ca-certificates curl software-properties-common
Voeg vervolgens de GPG-sleutel voor de officiële Docker-repository toe aan je systeem:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
Voeg de Docker-repository toe aan APT-bronnen:
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
Werk vervolgens de pakketdatabase bij met de Docker-pakketten uit de nieuw toegevoegde opslagplaats:
sudo apt update
Zorg ervoor dat je op het punt staat te installeren vanuit de Docker-opslagplaats in plaats van de standaard Ubuntu-opslagplaats:
apt-cache policy docker-ce
Je ziet de uitvoer als volgt, hoewel het versienummer voor Docker kan verschillen:
docker-ce:
Installed: (none)
Candidate: 5:19.03.9~3-0~ubuntu-focal
Version table:
5:19.03.9~3-0~ubuntu-focal 500
500 https://download.docker.com/linux/ubuntu focal/stable amd64 Packages
Merk op dat het docker-ceniet is geïnstalleerd, maar de kandidaat voor installatie komt uit de Docker-repository voor Ubuntu 20.04 ( focal).
Installeer ten slotte Docker:
sudo apt install docker-ce
Docker zou nu moeten zijn geïnstalleerd, de daemon zou moeten zijn gestart en het proces zou ingeschakeld moeten zijn om te starten bij het opstarten. Controleer of het werkt:
sudo systemctl status docker
De uitvoer moet eruit zien dat Docker actief is.
Als je Docker nu installeert, krijgt u niet alleen de Docker-service (daemon) maar ook het dockeropdrachtregelprogramma of de Docker-client.
Docker commando uitvoeren zonder Sudo
Standaard kan de dockeropdracht alleen worden uitgevoerd door de rootgebruiker of door een gebruiker in de dockergroep, die automatisch wordt aangemaakt tijdens het installatieproces van Docker. Als je de dockeropdracht probeert uit te voeren zonder er een voorvoegsel aan te geven, met sudoof zonder in de docker groep te zijn, krijg je een uitvoer als deze:
Output
docker: Cannot connect to the Docker daemon. Is the docker daemon running on this host?. See 'docker run --help'.
Als je niet elke keer sudowilt typen wanneer je de dockeropdracht uitvoert, voeg je je gebruiker toe aan de dockergroep:
sudo usermod -aG docker ${USER}
Om het nieuwe groepslidmaatschap toe te passen, log je uit bij de server en weer in, of typ je het volgende:
su - ${USER}
Je wordt gevraagd om je gebruikerswachtwoord in te voeren om door te gaan.
Bevestig dat je gebruiker nu is toegevoegd aan de docker groep door te typen:
id -nG
Output
patrick sudo docker
Als je een gebruiker moet toevoegen aan de dockergroep waarbij je niet bent aangemeld, geef die gebruikersnaam dan expliciet op met:
sudo usermod -aG docker username
In de rest van deze les wordt ervan uitgegaan dat je de dockeropdracht uitvoert als gebruiker in de dockergroep. Als je ervoor kiest om dit niet te doen, plaatst je de opdrachten vooraf met sudo.
Laten we docker onderzoeken .
Het docker commando gebruiken
Commando dockerbestaat uit het doorgeven van een reeks opties en opdrachten gevolgd door argumenten. De syntaxis heeft deze vorm:
docker [option] [command] [arguments]
Om alle beschikbare subopdrachten te zien, typ je:
docker
Om de beschikbare opties voor een specifieke opdracht te zien, typ je:
docker docker-subcommand --help
Om systeembrede informatie over Docker te bekijken, gebruik je:
docker info
Laten we enkele van deze commando's onderzoeken. We beginnen met het werken met images.
Werken met Docker images
Docker-containers worden gemaakt op basis van Docker-installatiekopieën. Docker haalt deze images standaard uit Docker Hub, een Docker-registry beheerd door Docker, het bedrijf achter het Docker-project. Iedereen kan zijn Docker-images hosten op Docker Hub, dus voor de meeste applicaties en Linux-distributies die je nodig hebt, worden daar images gehost.
Om te controleren of je images kunt openen en downloaden van Docker Hub, typ je:
docker run hello-world
De uitvoer geeft aan dat Docker correct werkt:
Output
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
0e03bdcc26d7: Pull complete
Digest: sha256:6a65f928fb91fcfbc963f7aa6d57c8eeb426ad9a20c7ee045538ef34847f44f1
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
...
Docker kon de hello-worldimage aanvankelijk niet lokaal vinden, dus het heeft de image gedownload van Docker Hub, de standaardrepository. Nadat de image is gedownload, creëert Docker een container van de image en werd de toepassing in de container uitgevoerd, waarbij het bericht werd weergegeven.
Je kunt zoeken naar images die beschikbaar zijn op Docker Hub door de dockeropdracht met de searchsubopdracht te gebruiken. Om bijvoorbeeld naar de Ubuntu-image te zoeken, typ je:
docker search ubuntu
Het script crawlt Docker Hub en retourneert een lijst met alle images waarvan de naam overeenkomt met de zoekreeks.
In de OFFICIAL kolom geeft OK een image aan die is gebouwd en ondersteund door het bedrijf achter het project. Als je eenmaal de image hebt geïdentificeerd die je wilt gebruiken, kun je deze met de pullsubopdracht naar je computer/server downloaden.
Voer de volgende opdracht uit om de officiële ubuntuafbeelding naar je computer/server te downloaden :
docker pull ubuntu
Je ziet de volgende output:
Output
Using default tag: latest
latest: Pulling from library/ubuntu
d51af753c3d3: Pull complete
fc878cd0a91c: Pull complete
6154df8ff988: Pull complete
fee5db0ff82f: Pull complete
Digest: sha256:747d2dbbaaee995098c9792d99bd333c6783ce56150d1b11e333bbceed5c54d7
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest
Nadat een image is gedownload, kun je een container uitvoeren met behulp van de gedownloade image met het runsubcommando. Zoals je bij het hello-worldvoorbeeld hebt gezien, zal de Docker-client eerst de image downloaden en vervolgens een container gebruiken als er geen image is gedownload wanneer deze dockerwordt uitgevoerd met het runsubcommando.
Om de images te zien die naar je computer/server zijn gedownload, typ je:
docker images
De uitvoer ziet er uit met de inhoud van alle images die lokaal staan op je computer/server:
Laten we eens kijken hoe je containers in meer detail kunt uitvoeren.
Een Docker container uitvoeren
De hello-worldcontainer die je in de vorige stap hebt uitgevoerd, is een voorbeeld van een container die wordt uitgevoerd en afgesloten na het verzenden van een testbericht. Containers kunnen veel nuttiger zijn dan dat, en ze kunnen interactief zijn. Ze lijken tenslotte op virtuele machines, maar zijn resource-vriendelijker.
Laten we als voorbeeld een container uitvoeren met de nieuwste image van Ubuntu. De combinatie van de -i en -t opties geeft je interactieve shell-toegang tot de container:
docker run -it ubuntu
Je opdrachtprompt moet veranderen om het feit weer te geven dat je nu in de container werkt en zou deze vorm moeten hebben:
Output
root@d9b100f2f636:/#
Let op de container-ID in de opdrachtprompt. In dit voorbeeld is het d9b100f2f636. Je hebt die container-ID later nodig om de container te identificeren wanneer je deze wilt verwijderen.
Nu kun je elke opdracht in de container uitvoeren. Laten we bijvoorbeeld de pakketdatabase in de container bijwerken. Je hoeft geen commando voor te voegen sudo, omdat je in de container werkt als de rootgebruiker :
apt update
Installeer vervolgens elke applicatie erin. Laten we Node.js installeren:
apt install nodejs
Dit installeert Node.js in de container vanuit de officiële Ubuntu-repository. Als de installatie is voltooid, controleert je of Node.js is geïnstalleerd:
node -v
Je ziet het versienummer weergegeven in je terminal:
Output
v10.19.0
Alle wijzigingen die je in de container aanbrengt, zijn alleen van toepassing op die container.
Typ exitbij de prompt om de container te verlaten .
Laten we nu eens kijken naar het beheren van de containers op ons systeem.
Docker containers beheren
Nadat je Docker een tijdje hebt gebruikt, heb je veel actieve en inactieve containers op je computer/server. Om de actieve te zien, gebruik:
docker ps
Je ziet een output die lijkt op de volgende:
Output
CONTAINER ID IMAGE COMMAND CREATED
In deze les heb je twee containers gestart; een uit de hello-worldafbeelding en een andere uit de ubuntuafbeelding. Beide containers draaien niet meer, maar ze staan nog steeds op je systeem.
Om alle containers te zien - actief en inactief, voert u uit docker ps met de -aschakelaar:
docker ps -a
U ziet een output die alle actieve en inactieve containers toont.
Om de laatste container die je hebt gemaakt te bekijken, geeft je deze de -loptie mee:
docker ps -l
Om een gestopte container te starten, gebruik je docker start, gevolgd door de container-ID of de naam van de container. Laten we de op Ubuntu gebaseerde container starten met de ID van 1c08a7a0d0e4:
docker start 1c08a7a0d0e4
Gebruik docker stop, gevolgd door de container-ID of -naam om een actieve container te stoppen. Deze keer gebruiken we de naam die Docker aan de container heeft toegewezen, namelijk quizlet_joy:
docker stop quizlet_joy
Als je eenmaal hebt besloten dat je een container niet langer nodig hebt, verwijder je deze met de docker rmopdracht, opnieuw met behulp van de container-ID of de naam. Gebruik de docker ps -aopdracht om de container-ID of naam te zoeken voor de container die aan de hello-worldafbeelding is gekoppeld en deze te verwijderen.
docker rm youthtest_blanco
Je kunt een nieuwe container starten en deze een naam geven met de --nameoptie. Je kunt de --rmoptie ook gebruiken om een container te maken die zichzelf verwijdert wanneer deze wordt gestopt. Zie de docker run helpopdracht voor meer informatie over deze en andere opties.
Snapshot maken
Maak een snapshot van je net gemaakte Docker-server.
Opdracht Docker-server
De opdracht voor het maken van een docker-server met het ophalen van images en het maken van containers staat op ItsLearning. Opdracht maken en weer inleveren op ItsLearning.
Les 7: Wiki
Tiki Wiki is een gratis en opensource content management systeem (CMS) gebouwd op de LAMP- of LEMP-stack waarmee je wiki-gebaseerde websites kunt maken voor elk doel (wiki's, blogs, forums) voor intern en extern gebruik.
Of je nu een persoonlijke of zakelijke wikisite bouwt, Tiki Wiki CMS kan je helpen bij het maken en beheren van je inhoud op elk apparaat met zijn gebruiksvriendelijke en krachtige beheerdersdashboard.
Als je een wiki-gebaseerde of forumwebsite wilt runnen en deze functies zijn niet beschikbaar in je huidige CMS-systemen, kies je misschien voor Tiki Wiki CMS.
Deze applicatie is zowel voor een Ubuntu-server omgeving zoals wij die nu gaan installeren/configureren, hij is er ook voor Docker omgevingen in een container.
Voorbereiding
- Zorg dat de Ubuntu-server weer basis gereed is.
- Zet de snapshot terug
- Zorg voor de SSH verbinding naar de server.
of
- Zorg ervoor dat voorgaande applicaties verwijderd zijn van de server.
Apache2 installeren
Stap 1. Apache installeren
Apache2 HTTP Server is een van de meest populaire webserver die in gebruik is, Tiki Wiki heeft het nodig om de website te hosten.
Om Apache2 HTTP op de Ubuntu-server te installeren, voert je de onderstaande opdrachten uit.
sudo apt update
sudo apt install apache2
Stap 2. Apache2 toevoegen aan UFW
Zoals eerder geleerd moeten we Apache2 toevoegen aan UFW.
sudo ufw app list
sudo ufw allow Apache
Testen
Om de Apache2 installatie te testen, open je je browser en blader je naar de serverhostnaam of het IP-adres en je zou de Apache2-landingpage moeten zien, zoals hieronder weergegeven. Als je dat ziet, werkt Apache2 zoals verwacht.
MariaDB installeren
De MariaDB-databaseserver is een goede oplossing als open source-databaseservers. Om MariaDB te installeren, voer je de onderstaande opdrachten uit.
sudo apt install mariadb-server mariadb-client
Na installatie van MariaDB kunnen de onderstaande commando's worden gebruikt om de MariaDB-service te stoppen, te starten en in te schakelen om altijd op te starten wanneer de server opstart.
sudo systemctl stop mariadb.service
sudo systemctl start mariadb.service
sudo systemctl enable mariadb.service
Voer daarna de onderstaande opdrachten uit om de MariaDB-server te beveiligen door een root-wachtwoord aan te maken en root-toegang op afstand niet toe te staan.
sudo mysql_secure_installation
Beantwoord de onderstaande vragen door de wizard te volgen wanneer daarom wordt gevraagd.
- Enter current password for root (enter for none): druk gewoon op Enter
- Change the root password? [Y/n]: y
- Nieuw wachtwoord: voer het wachtwoord in
- Nieuw wachtwoord opnieuw invoeren: wachtwoord herhalen
- Remove anonymous users? [Y/n]: y
- Disallow root login remotely? [Y/n]: y
- Remove test database and access to it? [Y/n]: y
- Reload privilege tables now? [Y/n]: y
Start de MariaDB-server opnieuw
sudo systemctl restart mariadb.service
Om te testen of MariaDB is geïnstalleerd, typ je de onderstaande opdrachten om in te loggen op de MariaDB-server
sudo mysql -u root -p
Typ vervolgens het wachtwoord
PHP installeren
PHP 7.4 is standaard beschikbaar voor APT.
Voer vervolgens de onderstaande opdrachten uit om PHP en gerelateerde modules te installeren.
sudo apt install php php-cli php-fpm php-json php-common php-mysql php-zip php-gd php-mbstring php-curl php-xml php-pear php-bcmath php-intl php-ldap php-soap
Om te controleren welke versie van PHP er geïnstalleerd is.
php --version
Voer na het installeren van PHP de onderstaande opdrachten uit om het standaard PHP-configuratiebestand voor Apache2 te openen.
sudo nano /etc/php/7.4/apache2/php.ini
Breng vervolgens de wijzigingen aan op de volgende regels hieronder in het bestand en sla op. De onderstaande waarde zijn goede instellingen om in je omgevingen toe te passen.
file_uploads = On
allow_url_fopen = On
short_open_tag = On
memory_limit = 256M
upload_max_filesize = 100M
max_execution_time = 360
date.timezone = Europe/Amsterdam
Nadat u de bovenstaande wijziging hebt aangebracht, slaat u het bestand op en sluit u het af.
Start Apache2 opnieuw
Na het installeren van PHP en gerelateerde modules, hoef je alleen maar Apache2 opnieuw te starten om PHP-configuraties te laden.
Voer de onderstaande opdrachten uit om Apache2 opnieuw te starten
sudo systemctl restart apache2.service
Om PHP instellingen met Apache2 te testen, maakt u een phpinfo.php bestand in de Apache2-hoofd directory door de onderstaande opdrachten uit te voeren
sudo nano /var/www/html/phpinfo.php
Typ vervolgens de onderstaande inhoud en sla het bestand op.
<?php phpinfo( ); ?>
Sla het bestand op, blader vervolgens naar het IP-adres van uw server gevolgd door /phpinfo.php.
VERWIJDER de phpinfo.php!!!!
PHP is nu juist geconfigureerd, uit veiligheidsoverwegingen moeten we geen informatie hosten over gebruikte versies, enz op onze website.
sudo rm /var/www/html/phpinfo.php
Magento-database maken
Nu je alle pakketten hebt geïnstalleerd die nodig zijn om Tiki Wiki CMS te laten functioneren, ga je hieronder verder om te beginnen met het configureren van de server. Voer eerst de onderstaande opdrachten uit om een lege Magento-database te maken.
Voer de onderstaande opdrachten uit om je aan te melden bij de MariaDB-databaseserver.
sudo mysql -u root -p
Maak vervolgens een database met de naam tikiwiki.
CREATE DATABASE tikiwiki;
Maak een databasegebruiker met de naam tikiuser met een nieuw wachtwoord
CREATE USER 'tikiuser'@'localhost' IDENTIFIED BY 'new_password_here';
Geef de gebruiker vervolgens volledige toegang tot de database.
GRANT ALL ON tikiwiki.* TO 'tikiuser'@'localhost' IDENTIFIED BY 'user_password_here' WITH GRANT OPTION;
Sla ten slotte uw wijzigingen op en sluit af.
FLUSH PRIVILEGES;
EXIT;
Download en installeer Tiki Wiki
Voer de onderstaande opdrachten uit om Tiki Wiki-inhoud te downloaden.
cd /tmp && wget https://sourceforge.net/projects/tikiwiki/files/latest/download --no-check-certificate
sudo apt install unzip
unzip download
sudo mv tiki-22.0 /var/www/html/tikiwiki
Let op! Versie tiki-22.0 kan verschillen, controleer hier goed wat je uitgepakt hebt met unzip!
Voer vervolgens de onderstaande opdrachten uit om de machtigingen voor de hoofd directory te wijzigen.
sudo chown -R www-data:www-data /var/www/html/tikiwiki/
sudo chmod -R 755 /var/www/html/tikiwiki/
Configureer Apache2 Tiki Wiki website
Configureer ten slotte het Apache2-configuratiebestand voor Tiki Wiki. Dit bestand bepaalt hoe gebruikers toegang krijgen tot Tiki Wiki-inhoud. Voer de onderstaande opdrachten uit om een nieuw configuratiebestand te maken met de naam tikiwiki .conf
sudo nano /etc/apache2/sites-available/tikiwiki.conf
Kopieer en plak vervolgens de onderstaande inhoud in het bestand en sla het op. Vervang de regel "ServerName" door uw eigen domeinnaam en directory-rootlocatie.
<VirtualHost *:80>
ServerAdmin admin@example.com
DocumentRoot /var/www/html/tikiwiki
ServerName noorderpoort.com
<Directory /var/www/html/tikiwiki/>
Options FollowSymlinks
AllowOverride All
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
Sla het bestand op en sluit af.
Na het configureren van de bovenstaande VirtualHost, schakel je deze in door de onderstaande opdrachten uit te voeren.
Enable de Tiki Wiki website
Na het configureren van de bovenstaande VirtualHost, schakelt je deze in door de onderstaande opdrachten uit te voeren en start je de Apache2-server opnieuw op
sudo a2ensite tikiwiki.conf
sudo a2dissite 000-default.conf
sudo apache2ctl configtest
sudo systemctl restart apache2.service
Open vervolgens je browser en ga naar het IP-adres van je server en ga verder met de installatie.
http://{IP-adres}/
Klik op Volgende om door te gaan met de installatiewizard. Een van de meest opmerkelijke eigenschappen van Tiki Wiki CMS is de ingebouwde meertalige ondersteuning. In stap 2 worden de talen gekozen voor zowel de voorkant als de achterkant. De standaardtaal die u in deze stap selecteert, wordt weergegeven als de locale- module de taal van de browser niet kan bepalen.
Typ de databaseverbindingsinformatie die je eerder hebt gemaakt. Tiki vereist een actieve databaseverbinding. Je moet de database en de gebruiker maken voordat je deze pagina voltooit, tenzij je databasegebruiker ook machtigingen heeft om nieuwe databases te maken en deze niet alleen te gebruiken.
Volg voor de rest de Wizard.
Na de installatie, ga verder naar de configuratiepagina, hier stel je de algemene en algemene instellingen voor de site in. Je wilt HTTPS-aanmelding voor de admin-gebruiker uitschakelen als je dit nog niet hebt ingesteld.
Na het invoeren van je "Admin" wachtwoord kom je op de Tiki Setup pagina. Dit is het punt dat je Tiki Wiki website werkt.
Dit is de standaard home pagina van Tiki Wiki. Deze kun je nu naar wens aanpassen.
Opdracht Wiki
De opdracht voor Tiki Wiki staat gereed op ItsLearning. Opdracht maken, goed lezen wat de de configuratie moet zijn, screen-shots maken en inleveren op ItsLearning.
Les 8: Loadbalancer
Voor de loadbalancer hebben we meerdere servers nodig. Hiervoor gaan we een testomgeving maken waarin we snel en makkelijk een omgeving kunnen deployen waarmee we loadbalancing kunnen oefenen. De omgeving zal eruit gaan zien als hieronder.
Het huidige internet kan niet meer zonder loadbalancers. Deze verdelen de taken en zorgen ervoor dat server omgevingen bereikbaar blijven en taken verdeeld worden. Door het gebruik van meerdere loadbalancers kun je werken aan een High-Available omgeving. We gaan tijdens deze les onze eerste loadbalancer maken, in lateren lessen zullen we zelfs deze taak verdelen over meerdere servers.
Test omgeving
Om snel meerdere servers te kunnen deployen gaan we gebruik maken Vagrant en VirtualBox. Hiervoor moeten een aantal zaken geïnstalleerd zijn op je host computer. We zullen stap voor stap door de installatie heengaan en de Vagrant file maken. Echter er is ook een video die hierbij ondersteund.
Stap 1. Installeren virtualBox
Vagrant werkt met VirtualBox, zorg ervoor dat je de laatste versie hebt geïnstalleerd. VirtualBox is te downloaden via onderstaande webpagina.
virtualbox download
Stap 2. Installeren GIT-bash
Om een CLI omgeving te hebben dat goed werkt met Vagrant, gaan we gebruik maken van GIT-bash. Dit is een CLI dat je in staat stelt om Linux commando's uit te voeren in een Windows omgeving. GIT-bash is te downloaden via onderstaande link.
GIT-bash download
Stap 3. Installeren Vagrant
Vagrant is de applicatie dat heel snel virtuele omgeving kan maken aan de hand van 1 configuratie file. Deze genaamde Vagrantfile gaan we later maken, eerst moeten we Vargrant installeren. Download en installeer Vagrant via onderstaande link.
Vagrant download
Stap 4. Directory maken
Open GIT-bash en maak onderstaande directory's
cd Documents
mkdir vagrant && cd vagrant
mkdir loadbalancer && cd loadbalancer
Zorg ervoor dat je in deze directory staat, want hier gaan we de configuratie maken voor Vagrant.
Vagrantfile
Open nano en zorg ervoor dat de naam van het bestand Vagrantfile is. In dit bestand gaan we de configuratie maken. Hieronder een voorbeeld van de configurtatie dat we gaan maken.
Uitleg configuratie
Het eerste deel is een script dat uitgevoegd kan worden op alle servers die we aanmaken. Dus voor een snelle (standaard) configuratie kun je aan het begin van je bestand de standaard waardes configureren. Hier is gekozen voor een standaard gebruiker en wachtwoord, wat default directory's, enz.
Na het script worden de defaults voor de verschillende server bepaald. Hieronder zie je de dat het ingeladen moet worden in virtualbox, welke box aangemaakt moet worden (Ubuntu), hoeveel geheugen en cpu's de machines mogen gebruiken.
Na de basisconfiguratie kunnen we per server aangeven wat de instellingen moeten zijn. Hieronder een voorbeeld van een Ubuntu server. We moeten aangeven welke hostnaam hij krijgt, welk IP-adres, dat er gebruik gemaakt mag worden van het script dat we gemaakt hebben. Daarna een regel waarmee we het mogelijk maken om met SSH te verbinden met de servers, dit staat standaard uit. Daarna dat virtualbox hem moet gaan maken. Dit stuk moeten we per server doen of het 1 server is of 20 elke server krijgt zo'n gedeelte in het configuratie bestand.
Het volledige bestand is te vinden op de GIT. Hier staan meerdere voorbeelden van Vagrant configuratiebestanden.
GIT voor Vagrant configuratie voorbeelden
Zorg ervoor dat je 3 verschillende servers hebt, waarbij de IP-adressen verschillen en de namen ook. Je mag hiervoor gebruik maken van het configuratiebestand dat op GIT-hub staat. Deze voldoet aan de wensen voor de loadbalancer opdracht.
Vagrant commands
Hieronder staan verschillende opdrachten die we Vagrant kunnen laten uitvoeren. Zorg ervoor dat als je een opdracht uitvoert je dit doet in de map waar je Vagrantfile staat. Anders krijg je foutmeldingen.
Start VM's with Vagrant
vagrant up
Pause a VM
vagrant suspend
Restart a paused VM
vagrant resume
Stop and shutdown a VM
vagrant halt
Remove a VM
vagrant destroy
ssh in to the VM with Vagrant
vagrant ssh server1
vagrant ssh server2
vagrant ssh server3
ssh with password to the VM
ssh student@10.13.37.10
password: Welcome01
Omgeving
Maak van server2 en server3 beide een Apache of Nginx webserver. Hiervoor maak je gebruik van voorgaande lessen. De configuratie op beide server zal gelijk zijn.
index.html
Zorg ervoor dat de index.html verschillen om daarna te kunnen zien dat de loadbalancer ook echt het verkeer verdeeld tussen de beide servers.
Loadbalancer
De applicatie dat we gaan gebruiken op de loadbalancer is HAproxy. HAproxy is een redelijk makkelijk te configureren loadbalancer software, het enige wat we moeten doen is het installeren en de configuratie aanpassen op onze situatie.
Stap 1. Installeren HAproxy
sudo apt update
sudo apt install haproxy
Controleren
sudo systemctl status haproxy
Kopie maken van originele configuratie
sudo cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.original
Configuratie aanpassen
sudo nano /etc/haproxy/haproxy.cfg
Zorg ervoor dat de IP-adressen overeen komen met je eigen omgeving. Frontend is de kant naar het internet. Backend is de kant naar de webservers.
Als de configuratie is aangepast kun je HAproxy starten.
service haproxy start
Test de omgeving
Ga naar het IP-adres van je loadbalancer en druk op refresh om te zien dat de load daadwerkelijk wordt verdeelt over 2 webservers.
Statistieken van HAproxy
Je kunt ervoor kiezen om je statistieken van HAproxy te delen via een bepaalde poort. Hiervoor moet je een stuk toevoegen aan het configuratiebestand.
Als je nu naar het IP-adres van de loadbalancer gaat met daarachter /stats kom je op de statistieken pagina van HAproxy.
Loadbalancing methodes
Round Robin: dit algoritme wordt het meest geïmplementeerd. Het werkt door elke server achter de load balancer om beurten te gebruiken, op basis van hun gewicht. Het is waarschijnlijk ook het meest vloeiende en eerlijke algoritme, aangezien de verwerkingstijd van de servers gelijkmatig verdeeld blijft. Round Robin is een dynamisch algoritme waarmee het servergewicht onderweg kan worden aangepast.
Static Round Robin: Net als bij Round Robin, wordt elke server om de beurt gebruikt op basis van hun gewicht. In tegenstelling tot Round Robin is het wijzigen van het servergewicht echter geen optie. Er zijn echter geen ontwerpbeperkingen wat betreft het aantal servers. Wanneer een server omhoog gaat, wordt deze altijd onmiddellijk opnieuw in de farm geïntroduceerd zodra de volledige kaart opnieuw is berekend.
Least Connections: met dit algoritme ontvangt de server met het laagste aantal verbindingen de verbinding. Dit type taakverdeling wordt aanbevolen wanneer zeer lange sessies worden verwacht, zoals LDAP, SQL, enz. Het is echter niet goed geschikt voor protocollen die korte sessies gebruiken, zoals HTTP. Dit algoritme is ook dynamisch, net als Round Robin.
Source: dit algoritme hasht de bron-IP en deelt deze door het totale gewicht van actieve servers. Hetzelfde client-IP bereikt altijd dezelfde server, zolang er geen server down of up gaat. Als het hash-resultaat verandert als gevolg van het veranderende aantal actieve servers, worden clients naar een andere server geleid. Dit algoritme wordt over het algemeen gebruikt in de TCP-modus waar cookies niet kunnen worden geplaatst. Het is ook standaard statisch.
URI: dit algoritme hasht ofwel het linkerdeel van de URI, of de hele URI en deelt de hash-waarde door het totale gewicht van actieve servers. Dezelfde URI wordt altijd naar dezelfde server gestuurd, zolang er geen servers omhoog of omlaag gaan. Het is ook een statisch algoritme en werkt op dezelfde manier als het Source-algoritme.
URL-parameter: dit statische algoritme kan alleen worden gebruikt op een HTTP-backend. De opgegeven URL-parameter wordt opgezocht in de queryreeks van elke HTTP GET-aanvraag. Als de gevonden parameter wordt gevolgd door een gelijkteken en een waarde, wordt de waarde gehasht en gedeeld door het totale gewicht van actieve servers.
YouTube video
Opdracht Loadbalancer
De opdracht voor deze les staat op ItsLearning. Opdracht maken en zorg ervoor dat het principe van loadbalancing je duidelijk wordt.
Les 9: DHCP-server
DHCP is een service die wordt gebruikt om automatisch netwerkconfiguratie toe te wijzen aan clientsystemen. DHCP kan worden gebruikt als een handig hulpmiddel wanneer je een grote pool van systemen hebt die moeten worden geconfigureerd voor netwerkinstellingen. Bovendien, wanneer je de netwerkconfiguratie moet wijzigen, bijvoorbeeld om een DNS-server bij te werken, hoeft je alleen maar de DHCP-server bij te werken en worden alle aangesloten hosts opnieuw geconfigureerd met nieuwe instellingen. Je krijgt ook een betrouwbare IP-adresconfiguratie die configuratiefouten en adresconflicten tot een minimum beperkt. Je kunt eenvoudig een nieuwe host aan het netwerk toevoegen zonder tijd te besteden aan netwerkplanning.
DHCP wordt meestal gebruikt om IP-configuratie-instellingen op te geven, zoals IP-adres, subnetmasker, standaardgateway en DNS-servers. Het kan echter ook worden ingesteld om de tijdserver(NTP) en hostnaam op de client te configureren.
DHCP kan worden geconfigureerd om de volgende configuratiemethoden te gebruiken:
Handmatige toewijzing: hier zijn de configuratie-instellingen gekoppeld aan het MAC-adres van de netwerkkaart van de cliënt. Elke keer dat de cliënt een verzoek doet met dezelfde netwerkkaart, worden dezelfde instellingen opgegeven.
Dynamische toewijzing: deze methode specificeert een reeks IP-adressen die aan de clients moeten worden toegewezen. De server kan de IP-configuratie dynamisch toewijzen aan de client op basis van wie het eerst komt, het eerst maalt. Deze instellingen worden toegewezen voor een bepaalde periode, lease genaamd; na deze periode moet de klant opnieuw met de server onderhandelen om hetzelfde adres te blijven gebruiken. Als de client het netwerk voor een bepaalde tijd verlaat, vervalt de configuratie en keert deze terug naar de pool waar deze kan worden toegewezen aan andere clients. De leasetijd is een configureerbare optie en kan op oneindig worden ingesteld.
Installeren DHCP-server
Stap 1: Installeer een DHCP-server
sudo apt install isc-dhcp-server
Configureren van de DHCP-server
Stap 2: Open het DHCP-configuratiebestand:
sudo nano /etc/dhcp/dhcpd.conf
Stap 3: Wijzig indien nodig de standaard en maximale leasetijd:
default-lease-time 600;
max-lease-time 7200;
Stap 4: Voeg de volgende regels toe aan het einde van het bestand of un-comment het gedeelte dat hiervoor gemaakt is (vervang de IP-adressen zodat het overeenkomt met je netwerk):
subnet 192.168.1.0 netmask 255.255.255.0 {
range 192.168.1.80 192.168.1.90;
option routers 192.168.1.1;
option domain-name-servers 192.168.1.2, 192.168.1.3;
option domain-name "Noorderpoort";
}
Dit resulteert in IP-adressen variërend van 192.168.1.80 tot 192.168.1.90 die aan clients worden toegewezen. De standaard leasetijd is ingesteld op 600 seconden met een maximale limiet van 7200 seconden. Een cliënt kan een bepaalde tijd vragen tot een maximale leaseperiode van 7200 seconden. Bovendien biedt de DHCP-server een standaardgateway (routers) en standaard DNS-servers.
Stap 5: Je kunt een IP-adres reserveren om toe te wijzen aan een specifiek apparaat op het netwerk. Reserveren zorgt ervoor dat een gespecificeerd apparaat altijd aan hetzelfde IP-adres wordt toegewezen. Om een reservering te maken, voeg je de volgende regels toe aan dhcpd.conf. Het wijst IP 192.168.1.88 toe aan de client met het MAC-ID: 01:02:03:04:05:06
host Server1 {
hardware ethernet 01:02:03:04:05:06;
fixed-address 192.168.1.88;
}
Stap 6: Sla het configuratiebestand op en sluit af.
Stap 7: Start dhcpd opnieuw nadat je het configuratiebestand hebt gewijzigd.
sudo service isc-dhcp-server restart
Opdracht DHCP-server
De opdracht voor deze les staat op ItsLearning. Voor deze opdracht ben je een 2de netwerkkaart nodig op het interne-LAN van je virtuele machine.
