Flask ja tietokantasovellus

Tässä harjoituksessa toteutan palvelinpuolen ohjelman Python Flaskilla, tietokantana on PostgreSQL. Harjoitus on jatko mod_wsgi , PostgreSQL ja Flask-asennuksille. Mallia otettu täältä.

Asennetaan tarvittavat paketit

$ sudo apt-get -y install python3-flask-sqlalchemy python3-psycopg2

Pääohjelma testaamista vartan

# kanta.py
# modified from http://terokarvinen.com/2017/database-connection-from-python-flask-to-postgre-using-raw-sql
# done 3.10.2018

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
db = SQLAlchemy(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql:///juhawsgi'
app.config['SECRET_KEY'] = 'dfgdfgdfDFGDFGrteERTewasFRdasFGRd'

def sql(rawSql, sqlVars={}):
assert type(rawSql)==str
assert type(sqlVars)==dict
res=db.session.execute(rawSql, sqlVars)
db.session.commit()
return res

@app.before_first_request
def initDBforFlask():
sql("CREATE TABLE IF NOT EXISTS horses (id SERIAL PRIMARY KEY, name VARCHAR(160) UNIQUE);")
sql("INSERT INTO horses(name) VALUES ('Tanhupallo') ON CONFLICT (name) DO NOTHING;")
sql("INSERT INTO horses(name) VALUES ('Kira') ON CONFLICT (name) DO NOTHING;")
sql("INSERT INTO horses(name) VALUES ('Juha') ON CONFLICT (name) DO NOTHING;")
sql("INSERT INTO horses(name) VALUES ('Luumu') ON CONFLICT (name) DO NOTHING;"
)

@app.route("/")
def hello():
return "See you at JuhaImmonen.com! <a href='/horses'>List horses</a>\n"

@app.route("/horses")
def horses():
horses=sql("SELECT * FROM horses;")
return render_template("horses.html", horses=horses)

if __name__ == "__main__":
from flask_sqlalchemy import get_debug_queries
app.run(debug=True)

Templates

templates/horses.html

{% extends "base.html" %}

{%block title%} Horses {%endblock title%}

{% block contents %}
<h1>Horses</h1>
{% for horse in horses %}
<p>{{ horse.name }}</p>
{% endfor %}
{% endblock contents %}

templates/base.html

<!doctype html>
<html>
<head>
<title>
{%block title%}
Hello World
{%endblock title%}
</title>
<meta charset="utf-8" />
</head>
<body>
{% block contents %}
<h1>Hello World</h1>
<p>Let's test UTF-8 with "päivää"</p>
{% endblock contents %}
</body>
</html>

Testaus

Ajettu ohjelma menemällä URL: http://juhawsgi.juhaimmonen.com/

Ohjelma ei toimi, tulostuu “Internal Server Error”

Apachen error.log:ssa on paljon lokitusta. En tiedä tässä vaiheessa mikä on todellinen syy. Onko se tämä:

3
6] sqlalchemy.exc.OperationalError: (psycopg2.OperationalError) FATAL: role “juhawsgi” does not exist

Pitää luoda tietokanta ja käyttäjä, helpointa on käyttää teknistä käyttäjää juhawsgi, jolloin login PostgreSQL kantaan toimii automaattisesti.

Luodaan tietokanta ja käyttäjä

$ sudo -u postgres createdb juhawsgi
$ sudo -u postgres createuser juhawsgi

Ajettu uudelleen ohjelma menemällä URL: http://juhawsgi.juhaimmonen.com/

Nyt toimii ja tietokannasta saadaan myös dataa

Palvelinten hallinta – harjoitus 2

Harjoitustehtävien tekemistä kurssille palvelinten hallinta. Varsinaiset tehtävät ovat täällä.

Tehtävät on tehty omalla  Hewlett-Packard kotikoneella, jossa Ubuntu 18.04. Muistia 6 GB ja CPU on Intel i5 M 450 @ 2.40GHz.

Salt ympäristön asennus

Ympäristö oli asennettu jo aiemmin, tässä vielä lyhyesti Salt Master ja Slave asennus. Asennusohjeet on saatu täältä.

Master asennus

$ sudo apt-get update
$ sudo apt-get -y install salt-master
$ hostname -I
192.168.10.52

Orjakoneen asennus

$ sudo apt-get -y install salt-minion

Määritellään orjakoneelle, missä master palvelin sijaitsee.

$ sudoedit /etc/salt/minion
master: 192.168.10.52
id: slave1

Otetaan asetus käytöön

$ sudo systemctl restart salt-minion.service

Hyväksytään orjakone msterkoneella

$ sudo salt-key -A

Unaccepted Keys:
slave1
Proceed? [n/Y]
Key for minion slave1 accepted.

Testaus

juha@juha-HP:~$ sudo salt '*' cmd.run whoami
[sudo] password for juha: 
slave1:
root

1. Laita käyttäjien kotisivut toimimaan Apachella

Tehdään asennus ensin käsin, eli asennataan Apache ja sen jälkeen konfiguroidaan kotisivut toimimaan käyttäjien omista kotihakemistoista.

Lähteenä ovat kurssin ohjeet.

Manuaalinen asennus

Koska koneella oli jo Apache, poistan sen asennuksen ensin. Poistaminen vaatii sen selvittämistä, mistä paketeista (riippuvuuksia) Apache2:lla on.

Yritin saada niitä elvilel komennolla

$ apt-cache show apache2

Ja löytyi rivit:

Depends: lsb-base, procps, perl, mime-support, apache2-bin (= 2.4.29-1ubuntu4), apache2-utils (= 2.4.29-1ubuntu4), apache2-data (= 2.4.29-1ubuntu4), perl:any
....
Conflicts: apache2.2-bin, apache2.2-common
Replaces: apache2.2-bin, apache2.2-common
Poistin sitten seuraavat paketit
$ sudo apt-get purge apache2 apache2-utils apache2-bin apache2.2-common

Kokeiltu tämän jälkeen selaimella localhost, ja tulee “Unable to connect” virheilmoitus. Yllä oelva poisto ei kuitenkaan poista kaikkea, vielä jäi esim. oletussivu /var/www/html/index.html

Apachen asennus koneelle

$ sudo apt-get install apache2

Tämän jälkeen pitäisi aueta Apache oletusaloitussivu, mutta poisto ei ollut poistanut aivan kaikkea Apache dataa. Jatkoin kuitenkin harjoituksen tekemistä.

Muutetaan seuraavaksi oletussivun tekstit.

$ echo Moi | sudo tee sudoedit /var/www/html/index.htm

Käyttäjien kotihakemistosta ei vielä voi näyttää Web-sivuja. Joten luodaan public_html hakemisto käyttäjälle.

$ pwd
/home/juha$ mkdir public_html$ nano index.html
Tämä on xubuntun kotihakemisto

Kytketään kotisivut toimimaan ja tehdään apache restart

$ sudo a2enmod userdir
$ sudo systemctl restart apache2

Testataan

Seuraavaksi on siivottava apache2 asennus pois koneelta, jotta päästään kokeilemaan Apache2 asennusta ja kotisivujen sallimista Saltin avulla.

$ sudo apt-get purge apache2 apache2-utils apache2-bin apache2.2-common

Masterin asennus ja käyttäjän kotisivut toimimaan

Käytetään cmd.run komentoa

Tehdään tila Apachen asentamiseksi, ja testataan askel kerrallaan.

$ sumkdir /do srv/salt/apache
$ sudoedit /srv/salt/apache/init.sls

apache2:
  pkg.installed

Ajetaan Salt tila

$ sudo salt '*' state.apply apache

Testataan orjakoneella selaimella localhost, ja apache toimii. Selaimelle tulostuu Moi, kuten index.html on kirjoitettu.

Seuraavaksi muokataan Apachen aloitussivu halutuksi. Tehdään oma index.html tiedosto. Lisätään init.sls tiedostoon seuraavat rivit.

$ echo Terve Salt |sudo tee index.html
$ sudoedit /srv/salt/apache/init.sls

/var/www/html/index.html
  file.managed:
    - source: salt://apache/index.html

apache2service
  service.running: 
    - watch: 
      - file: /etc/


Kokeillaan

$ sudo salt '*' state.apply apache

Testataan selaimella localhost ja toimii.

Seuraavaksi tehdään tila, jolla sallitaan käyttäjien kotisivut. Ensimmäinen komento ajaa a2enmod userdir ja toinen tekee apachen restartin kun komento ajetaan.

a2enmod userdir:
 cmd.run:
   - creates: /etc/apache2/mods-enabled/userdir.conf

apache2restart: 
  service.running: 
    - name: apache2 
    - watch: 
       - cmd: 'a2enmod userdir'

Ajetaan komento

$ sudo salt '*' state.apply apache

Testataan ja toimii.

 

Tehdään sama symlinkin / tiedostojen avulla

Malli otettu Teron esimerkistä.

Muokataan init.sls tilaa seuraavaksi.

apache2:
 pkg.installed

/var/www/html/index.html:
 file.managed:
   - source: salt://apache/index.html

/etc/apache2/mods-enabled/userdir.conf:
 file.symlink:
   - target: ../mods-available/userdir.conf

/etc/apache2/mods-enabled/userdir.load:
 file.symlink:
   - target: ../mods-available/userdir.load

apache2restart:
 service.running:
   - name: apache2
   - watch:
     - file: /etc/apache2/mods-enabled/userdir.conf
     - file: /etc/apache2/mods-enabled/userdir.load

Poistetaan apachen asennus.

$ sudo apt-get purge apache2 apache2-utils apache2-bin apache2.2-common

Ajetaan tila

$ sudo salt '*' state.apply apache

Testataan ja toimii.

2. Laita PHP toimimaan käyttäjien kotisivuilla

Tehdään ensin käsin, ja sitten Saltilla.

Manuaalinen asennus

$ sudo apt-get install libapache2-mod-php

Testisivun tekeminen

$ nano index.php
<!DocTYPE html>
<HTML lang=”en”>
<HEAD>
<meta charset=”utf-8″ />
<TITLE>kotisivu</TITLE>
</HEAD>
<BODY>
Hello World!
<?php
print (2+2);
?>
</BODY>
</HTML>

PHP sallitaan käyttäjille muokkaamalla konfigurointitiedostoa:  /etc/apache2/mods-available/php7.2.conf. Komentoidaan <IfModule> osuus pois.

Apachen restart

$ sudo systemctl restart apache2

Testataan ja toimii.

 PHP asennus Saltilla

Tarvitaan /etc/apache2/mods-available/php7.2.conf tiedosto malliksi, ja kopioidaan se Salt tilan käyttöön.

Selvitetään mitä PHP manuaaliasennuksessa tapahtui ts. mitä tiedostoja muutettiin. Paketin asennus siis tekee tarvittavat symlinkit.

find -printf "%T+ %p\n"|sort
2018-11-03+15:52:46.1631412840 ./php7.2.conf 2018-11-03+15:52:46.1631412840 ./php7.2.load

Poistetaan libapache2-mod-php, jotta voidaan testata. Sen poistaminen ei kuitenkaan riitä, symboliset linkit jäävät jäljelle. Eli poistetaan Apache kokonaan.

$ sudo apt-get purge -y libapache2-mod-php

Asennetaan Apache

$ sudo salt '*' state.apply apache

Tehdään uusi tila

libapache2-mod-php:
  pkg.installed

/etc/apache2/mods-enabled/php7.2.conf:
  file.managed:
    - source: salt://php/php7.2.conf

apache2restart:
  service.running:
    - name: apache2
    - watch:
      - file: /etc/apache2/mods-enabled/php7.2.conf

Ajetaan PHP tila

$ sudo salt '*' state.apply php

Testataan ja toimii.

3. Rakenna tila (state), joka tekee Apachelle uuden nimipohjaisen virtuaalipalvelimen

Virtuaalihostia varten tarvitaan tiedostot.

/etc/hosts
/etc/apache2/sites-available/000-default.conf

Kopioidaan ne hakemistoon

/srv/salt/virtual

Muokataan tiedostoihin tarvittavat asetukset.

Tiedostoon hosts lisätään rivi

127.0.0.1 juha.example.com

Tiedosto 000-default.conf uudelleen nimetään juha.example.com ja sisältö

$ sudoedit /etc/apache2/sites-available/juha.example.com.conf

<VirtualHost *:80>

ServerName juha.example.com
ServerAlias www.juha.example.com
DocumentRoot /home/juha/public_html

<Directory /home/juha/public_html>

Require all granted

</Directory>

</VirtualHost>

Virtuaalihostin asennus tehdään komennolla, vaatii Apachen restartin.

$ sudo a2ensite invis.example.com
$ sudo systemctl restart apache2

Tila nimipohjaisen virtuaalipalvelimen hallintaan

$ sudoedit /srv/salt/virtual/init.sls

apache2:
  pkg.installed

/etc/hosts:
  file.managed:
    - source: salt://virtual/hosts

/etc/apache2/sites-available/juha.example.com.conf:
  file.managed:
    - source: salt://virtual/juha.example.com.conf

a2ensite juha.example.com.conf:
  cmd.run

apache2restart:
  service.running:
    - name: apache2
    - watch:
      - file: /etc/apache2/sites-available/juha.example.com.conf

Ajetaan tila

$ sudo salt '*' state.apply virtual

Toimii.

4. Tee tila, joka laittaa esimerkkikotisivun uusille käyttäjille

Laitetaan esimerkkikotisivu /etc/skel/:iin, niin se tulee automaattisesti adduser komennolla käyttäjiä luodessa.

Manuaalisesti tehtynä.

$ cd /etc/skel
$ sudoedit mkdir public_html
$ cd public_html
$ sudoedit index.html

<!DocTYPE html>
<HTML lang=”en”>
<HEAD>
<meta charset=”utf-8″ />
<TITLE>kotisivu</TITLE>
</HEAD>
<BODY>
Hello World!
</BODY>
</HTML>

Master osuus

Luodaan index.html tiedosto kansioon /srv/salt/user. Sisältö edellisessä kappaleessa.

$ sudoedit /srv/salt/user

/etc/skel/public_html:
  file.directory:
    - makedirs: True

/etc/skel/public_html/index.html:
  file.manager:
    - source: salt://user/index.html

Ajetaan tila

$ sudo salt '*' state.apply user

Testataan luomalla uusi käyttäjä, ja surffartaan hänen kotisivulleen.

$ sudo adduser matti

Selaimessa näkyy oikea teksti.

5. Eri asetukset. Tee Package-File-Service tilalla eri asetuksia kuin ne, mitä tehtiin tunnilla

Muutetaan tässä harjoituksessa SSH-demonin asetuksia siten, että banner tekstinä tulostuu “Tervetuloa”

Mallia otettu täällä.

Tila ssh:n hallintaan

openssh-server:
 pkg.installed

/etc/ssh/sshd_config:
 file.managed:
   - source: salt://sshd_config

sshd:
 service.running:
   - watch:
     - file: /etc/ssh/sshd_config

Kopioidaan sshd_config tiedosto hakemistoon /srv/salt/ssh.

$ sudo cp  /etc/ssh/sshd_config /srv/salt/ssh

Tehdään banner tiedosto

$ sudoedit /etc/ssh/sshd-banner

Tervetuloa

Muokataan sshd_config tiedostoa

$ sudoedit /srv/salt/ssh/sshd_config
Lisätään rivi
Banner /etc/ssh/sshd-banner

Ajetaan tila

$ sudo salt '*' state.apply ssh

Testataan ssh:ta

Pientä säätöä Saltilla

Tämä on palvelinten hallintakurssin harjoitus H1 tehtävä 6. Päätin kokeilumielessä tehdä tilakonfiguraation, joka pitää huolen siitä, että orjakoneella on Apache asennettuna ja käynnissä.

Orjakoneen status

Apache on jo asennettuna.

$ sudo systemctl status apache2

Uusi tilakonfiguraatio master koneelle

$ cd /srv/salt
$ sudoedit mkdir webservice
$ cd webservice
$ sudoedit init.sls
Make sure the apache service is running:
  service.running:
    - name: apache2

Testaus

$ sudo salt '*' state.apply webservice

Tulos

TOP.sls päälle automaattisesti

$ sudoedit /srv/salt/top.sls
base:
  'mono02':
    - webservice

Otetaan top.sls käyttöön saman tien, ja tila pitää huolen, että apache-palvelu on käynnissä orjakoneella.

$  sudo salt '*' state.highstate

Laitetietojen kerääminen koneilta saltin grains-mekanismilla

Harjoituksen koneet ovat kaksi virtuaaliserveriä, joista toinen on Master ja molemmilla koneilla on salt slave.

Salt grain-mekanismilla voi kerätä paljon erilaista tietoa orjakoneista. Alla käyty läpi omasta mielestä mielenkiintoisimpia teitoja, mitä koneista saa kerättyä Master-koneelle.

Grainien kerääminen

sudo salt '*' grains.items|less

Salt grain tarkemmin

Orjakoneelta löytyy tietoa mm.

 sudo salt '*' grains.item host

host:
ubuntu-mono-02

 $ sudo salt '*' grains.item osfinger

Ubuntu-18.04

 $ sudo salt '*' grains.item pythonversion

pythonversion:

– 3
– 6
– 6
– final
– 0

 

 

Salt state kokeilua

Kokeilin tässä harjoituksessa Salt tilaa, ja mallina käytin täältä löytyviä Salt tiloja. Tavoitteena tässä harjoituksessa on asentaa apache ja muokata apachen aloitussivu halutuksi.

Testiympäristönä käytin omaa Läppäriä, jossa Ubuntu 18.04. Asensin ensin samalle koneelle Salt Masterin ja Slaven.

Tilojen luonti

Luodaan hakemisto, jolle Salt tilojen konfigurointitiedostot tulevat.

$ sudo mkdir -p /srv/salt/

Luodaan hakemisto index.html tiedostolle. Luodaan myäs hAkemisto LAMP konfiguraatiolle, mutta aluksi konfiguraatioon tulee vain apache asennus.

$ sudo mkdir /webserver
$ sudo mkdir /lamp

Luodaan tilakonfiguraatiot

Webserver

Luodaan tänne pelkkä index.html tiedosto, tämän tiedoston orjat hakevat.

$ sudoedit /salt/srv/webserver/index.html

<!DOCTYPE html>
<html>
<body>
Hello kaikki!
</body>
</html>

LAMP tilan konfiguraatio

Tila sisältää Apache:n asentamisen, jos sitä ei ole orjakoneella jo asennettuna. Tila sisältää myös Apachen index.html tiedoston viemisen oikeaan hakemistoon.

$ sudoedit /salt/srv/lamp/init.sls

install_lamp:
pkg.installed:
- pkgs:
- apache2

/var/www/html/index.html:
file:
- managed
- source: salt://webserver/index.html
- require:
- pkg: install_lamp

LAMP tilan testaus

Testataan, että Apachen asennus ja index.html tiedoston vieminen oikeaan paikkaan orjakoneella toimivat.

sudo salt '*' state.apply lamp

Tulos

$ sudo salt '*' state.apply lamp

slave1:
----------
ID: install_lamp
Function: pkg.installed
Result: True
Comment: All specified packages are already installed
Started: 19:14:23.920089
Duration: 1030.893 ms
Changes: 
----------
ID: /var/www/html/index.html
Function: file.managed
Result: True
Comment: File /var/www/html/index.html updated
Started: 19:14:24.955357
Duration: 34.369 ms
Changes: 
----------
diff:
--- 
+++ 
@@ -1 +1,8 @@
-Moi
+ <!DOCTYPE html>
+<html>
+<body>
+
+Hello kaikki!
+
+</body>
+</html>

Summary for slave1
------------
Succeeded: 2 (changed=1)
Failed: 0
------------
Total states run: 2
Total run time: 1.065 s

LAMP tila toimii, Apache oli jo aiemmin asennettuna. Samoin index.html tiedosto, mutta se ylikirjoitettiin.

Apache palauttaa nyt oikean index.html sisällön

TOP tilan luominen

TOP tilalla voidaan konfiguroida mille kaikille orjakoneille kohdistuu mikäkin tila. Orjat myös pitävät itsensä automaattisesti tilan mukaisessa konfiguraatiossa.

$ sudoedit /srv/salt/top.sls

base:
  '*':
    - lamp

Testataan TOP konfiguraatio

juha@juha-HP:/srv/salt$ sudo salt '*' state.highstate
slave1:
----------
ID: install_lamp
Function: pkg.installed
Result: True
Comment: All specified packages are already installed
Started: 19:24:45.334768
Duration: 994.227 ms
Changes: 
----------
ID: /var/www/html/index.html
Function: file.managed
Result: True
Comment: File /var/www/html/index.html is in the correct state
Started: 19:24:46.333198
Duration: 20.692 ms
Changes:

Summary for slave1
------------
Succeeded: 2
Failed: 0
------------
Total states run: 2
Total run time: 1.015 s

TOP tila toimii myös.

Localhost

Salt Master ja Slave pull-arkkitehtuuri

Salt Master ja Slave pull-arkkitehtuuri testausta kurssilta palvelinten hallinta.

OS: Ubuntu 18.04 LTS Master ja Slave koneella.

Master on oma tietokone (läppäri), slave on virtuaalikone Digital Ocean palvelussa.

Master asennus

$ sudo apt-get -y install salt-master
$ hostname -I
192.168.10.52

Master koneella on palomuuri, avataan siihen reiät Saltia varten portteihin 4505/tcp and 4506/tcp.

$ sudo ufw allow 4505/tcp
$ sudo ufw allow 4506/tcp

Slave asennus

$ sudo apt-get -y install salt-minion

Jokaisella orjakoneella pitää olla yksilöivä id ja orjakoneen pitää tietää missä Master-kone sijaitsee. Määritys tehdään tiedostoon /etc/salt/minion

$ sudoedit /etc/salt/minion
master: 192.168.10.52
id: mono1

Jotta asetus tulisi voimaan, pitää tehdä Salt restart orjakoneella. Orjakone ilmoittaa Master-koneelle oman avaimensa, ja Master-koneella voidaan käydä hyväksymässä kone orjaksi.

$ sudo systemctl restart salt-minion.service

Slaven hyväksyntä Masterin hallinnoitavaksi

Orjakoneen avaimen hyväksyntä tapahtuu komennolla, jos kaikki on mennyt hyvin.

$ sudo salt-key -A
The key glob '*' does not match any unaccepted keys.

Jostain syystä Masterilla ei ole orjakoneen avainta tiedossa. Aloitetaan lokien tutkinta. Lähteenä https://docs.saltstack.com/en/latest/ref/configuration/logging/

Lokit löytyy

/var/log/salt/minion

siellä virheilmoitus

2018-10-26 11:46:40,696 [salt.minion :878 ][ERROR ][25772] Error while bringing up mini on for multi-master. Is master at 192.168.10.52 responding?

Loppupäätelmä on, että Master koneen IP on NAT takana. Elisa on ISP. Oman koneen ufw-lokista ei näy mitään yrityksiä päästä koneelle.

Jälkikäteen tajusin, että olisin voinut vaihtaa vain koneiden roolit ja kaikki olisi todennäköisesti toiminut. Mutta päätin asentaa uuden virtuaalipalvelimen Masteriksi.

Uusi Master-kone

Rakensin uuden Master-koneen tekemällä uuden virtuaalikoneen digitalOcean palveluun. Ohje on täällä.

Master koneen IP on 142.93.133.2.

Tehty tämän jälkeen uudella Master koneella

$ sudo apt-get -y install salt-master
$ hostname -I
142.93.133.2

Master koneella on palomuuri, avataan siihen reiät Saltia varten portteihin 4505/tcp and 4506/tcp.

$ sudo ufw allow 4505/tcp
$ sudo ufw allow 4506/tcp

Salt slave asetusten korjaus

$ sudoedit /etc/salt/minion
master: 142.93.133.2
id: mono02

Slaven hyväksyntä uudelle Masterille

$ sudo salt-key -A

Unaccepted Keys:
mono02
Proceed? [n/Y]
Key for minion mono02 accepted.

Kokeiluita

master$ sudo salt '*' cmd.run 'hostname -I'

sudo salt '*' grains.items|less
sudo salt '*' grains.items

$ sudo salt '*' grains.item virtual
$ sudo salt '*' pkg.install httpie
$ sudo salt '*' sys.doc|less

Lähde

http://terokarvinen.com/2018/salt-quickstart-salt-stack-master-and-slave-on-ubuntu-linux

 

Labraharjoitus

Valmistautumista labraharjoitukseen vanhan tehtävän avulla.

Tehtävä.

Asenna Linux

Asennetaan Linux USB-tikulta, siten että koneelle ladataan ensin Linux USB-tikulta. Tällöin voi käyttää nettiä asennuksen ajan tiedon hakuun.

Asennuksen aikana kirjoita ylös luodut salasanat.

Asennuksen jälkeen umounttaa USB-tikku ennen poistoa USB-asemasta.

Huomioita asennuksen aikana ja jälkeen

Oma WordPress sivustolle syötetyt tunnukset ja salasanat menevät http-yhteyden yli. Jatkossa pitää opetalla https-yhteyden tekeminen.

Päivitys

Muista päivittää Ubuntu

$ sudo apt-get update

$ sudp apt-get upgrade

Kuvakaappauksia varten shutter

$ sudo apt-get install shutter

Suorituskyvyn seuranta päälle

$ sudo apt-get -y install sysstat
$ sudoedit /etc/default/sysstat
$ cat /etc/default/sysstat
ENABLED="true"
$ sar

Palomuuri päälle

$ sudo ufw allow 22/tcp

$ sudo ufw allow 80/tcp

$ sudo ufw enable

Luodaan käyttäjät tehtävän mukaan

## Työntekijät

Työntekijöitämme ovat Joe Doe, Jorma Mähkylä, Pekka Hurme, Ronaldo Smith,
Håkan Petersson ja Einari Mikkonen.

Laita einarin käyttäjätunnukseksi "einari". 

Tee kullekin käyttäjälle esimerkkikotisivu.

Skeleton käyttäjien luontiin

Kokeillaan Skeletonin käyttöä, jotta saadaan käyttäjien asetusten luonti automatisoitua. Uusien käyttäjien (‘sudo adduser user’) kotihakemistoon kopioidaan automaattisesti tiedostot /etc/skel/ alta.

$ cd /etc/skel

$ sudoedit mkdir public_html

$ cd public_html

$sudoedit index.html

<!DocTYPE html>
<HTML lang=”en”>
<HEAD>
<meta charset=”utf-8″ />
<TITLE>kotisivu</TITLE>
</HEAD>
<BODY>
Hello World!
</BODY>
</HTML>

Asennetaan SSH ja salasanojen luontia helpottava pwgen

$ sudo apt-get install ssh

$ sudo apt-get install pwgen

Luodaan tiedosto harjoituksen salasanoja varten

$ cd

$pwd

$ touch sala.txt

$ chmod og-wrx sala.txt

$ ls -l

Testataan SSH

$ ssh juha@localhost

$ ssh juha@ip-osoite

Testataan käyttäjän luonti

$ sudo adduser einari

$ ssh einari@localhost

Tiedostot ovat einarin omistuksesssa.

Asennetaan LAMP

## LAMP

Asenna LAMP - Linux, Apache, MySQL, PHP. 

Tee einarin kotihakemistoon esimerkkisovellus, joka näyttää tietueita
tietokannasta.

Apache asennus

$ sudo apt-get install apache2

Testaus

$ echo Moi | sudo tee /var/www/html/index.html

Käyttäjän kotisivut näkyviin kotihakemistosta

$ sudo a2enmod userdir

$ sudo systemctl restart apache2

MariaDB asennus

$ sudo apt-get update
$ sudo apt-get -y install mariadb-client mariadb-server
$ sudo mysql_secure_installation

Set root password? [Y/n]
New password:
Re-enter new password:
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

Kirjaudutaan sisään MariaDB rootina

$ sudo mariadb -u root

Luodaan tietokanta ja taulu tietokantaan

MariaDB [(none)]> CREATE DATABASE animals;

MariaDB [(none)]> USE animals;

MariaDB [animals]> CREATE TABLE animals (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(1024));

MariaDB [animals]> SHOW TABLES;

Tehdään käyttäjä

MariaDB [animals]> GRANT ALL ON animals.* TO animals@localhost IDENTIFIED BY ‘salainen’;

Kirjaudutaan normaalina käyttäjä kantaan

$ mariadb -u animals -p

Lisätään muutama rivi dataa tietokantaan

Database changed
MariaDB [animals]> INSERT INTO animals(name) VALUES (“Horse”);
MariaDB [animals]> INSERT INTO animals(name) VALUES (“Cat”);
MariaDB [animals]> INSERT INTO animals(name) VALUES (“Dog”);
MariaDB [animals]> INSERT INTO animals(name) VALUES (“Snake”);

Automatisoidaan sisäänkirjautuminen

$ touch .my.cnf
$ chmod og-wxr .my.cnf
$ ls -l .my.cnf$ nano .my.cnf

$ nano .my.cnf

user=”animals”
database=”animals”
password=”salainen”

PHP asennus

$ sudo apt-get install libapache2-mod-php php-mysql

Testaus

Sallitaan PHP käyttäjille

$ sudo /etc/apache2/mods-available/php7.2.conf

Kommentoidaan nämä pois

<IfModule mod_userdir.c>
<Directory /home/*/public_html>
php_admin_flag engine Off
</Directory>
</IfModule>

Tehdään testiohjelma

$ ssh einari@localhost

$ cd public_html

$ mv index.html index.php

$ nano index.php

<!DocTYPE html>
<HTML lang=”en”>
<HEAD>
<meta charset=”utf-8″ />
<TITLE>kotisivu</TITLE>
</HEAD>
<BODY>
Hello World!
<?php
print (2+2);
?>
</BODY>
</HTML>

Ajetaan testiohjelma

Tietokantaa käyttävä PHP-ohjelma

<?php

$user='animals';
$password='salainen';

$database=$user;
$dsn="mysql:host=localhost;charset=UTF8;dbname=$database";

$pdo=new PDO($dsn, $user, $password);

// Perform SQL Query
$pdoStatement=$pdo->prepare('SELECT * FROM animals;');
$pdoStatement->execute();
$hits=$pdoStatement->fetchAll();

// Print the $hits Array
foreach($hits as $row) {
 echo "<p>".$row['id']." ".$row['name']."</p>\n";
}
?>

Virtual host

Laita Einarin esimerkkisovellus näkymään osoitteesta

http://invis.example.com.

Voit simuloida nimipalvelun toimintaa hosts-tiedoston avulla.

sudoedit /etc/hosts

127.0.0.1 localhost
127.0.1.1 juha-HP
127.0.0.1 invis.example.com

Apachen konfigurointi

$ sudoedit /etc/apache2/sites-available/invis.example.com.conf

<VirtualHost *:80>

ServerName invis.example.com
ServerAlias www.invis.example.com
DocumentRoot /home/einari/public_html

<Directory /home/einari/public_html>

Require all granted

</Directory>

</VirtualHost>

$ sudo a2ensite invis.example.com

$ sudo systemctl restart apache2

Testaus

BASH-tehtävä

## mitakello

Tee uusi komento 'mitakello', joka tulostaa kellonajan. Komennon tulee
toimia kaikilla käyttäjillä, kaikista hakemistoista pelkällä nimellä
kutsuttuna.

$ nano juhatime.sh

#! /bin/bash
date –iso-8601=min

$ chmod u+x juhatime.sh

Ajetaan

./juhatime.sh

Kaikille käyttäjille

sudo cp juhatime.sh /usr/local/bin/juhatime.sh
[sudo] password for juha:

$ sudo chmod a+x juhatime.sh
/usr/local/bin$ ls -l juhatime.sh
-rwxr-xr-x 1 root root 33 loka 6 14:28 juhatime.sh

Metapaketti

Tee meille metapaketti, joka asentaa ohjelmat: git, httpie, curl, mitmproxy. 

Kuulemma "karvinen equivs" hakusanalla saattaisi löytyä ohjeita. Liitä
metapaketin
lähdekoodi palautettavan lab.txt:n loppuun.

Lähdekoodi tiedostossa juhas-pack.cfg

section: misc
Priority: optional
Standards-Version: 3.9.2
Package: juhas-pack
Version: 0.1
Depends: git, httpie, curl, mitmproxy
Description:
long description and info
.
second paragraph

 

PostgreSQL asennus

Tämä on jatkoa Linux kurssin harjoitustehtäville. Tavoitteena saada Python Flask kehitysympäristö toimimaan PostgreSQL tietokannan kanssa.

Seuraavaksi asennan PostgreSQL:n ja testaan SQL CRUD operaatiot.

Asennus

Asennetaan PostgreSQL

$ sudo apt-get -y install postgresql

Luodaan tietokanta käyttäjälle, joka on kirjautuneena.

$ sudo -u postgres createdb $(whoami)

Luodaan käyttäjä tietokantaan, siten että erillistä kirjautumista ei tarvita tietokantaan. Sama käyttäjä on siis unix- ja tietokantakäyttäjä.

$ sudo -u postgres createuser $(whoami)

Testaus

Kirjaudutaan sisään tietokantaan komennolla

$psql

Login onnistuu

CRUD operaatiot kannassa

Luodaan taulu (C: CREATE)

user => CREATE TABLE horses (id SERIAL PRIMARY KEY, name VARCHAR(200));

PRIMARY KEY id on luokseva numerosarja, eli rivin tunniste taulussa horses. Tietokanta genero isen automaatttisesti, kun uusi rivi lisätään tietokantaa horses-tauluun.

\d komennolla voi tutkia tietokannassa olevia tauluja.

\d horses näyttää taulun rakenteen / tiedot tarkemmin

Lisätään rivi tauluun (C:CREATE)

user=> INSERT INTO horses(name) VALUES (‘Lihapulla’);

user=> INSERT INTO horses(name) VALUES (‘Pasadoble’);

Jos halutaan INSERT lauseen palauttavan luodun rivin id:n, voidaan se tehdä komennolla

INSERT INTO horses(name) VALUES (‘Emir’) RETURNING id, name;

Luetaan tietoa tietokannan taulusta (SELECT)

SELECT lausella voidaan hakea tietoa

user=> SELECT * FROM horses;

Päivitetään tietoa taulussa (UPDATE)

UPDATE lauseella voidaan päivittää tietokannan tietoa.

user=> UPDATE horses SET name=’Ruuna’ WHERE name = ‘Lihapulla’;

SELECT lauseella voidaan tarkistaa tulos

user => SELECT * FROM horses;

Rivin poistaminen (DELETE)

user => DELETE * FROM horses WHERE name =’Ruuna’;

user => SELECT * FROM horses;

Lähde

 

 

 

 

Flask asennus

Jatketaan aiempaa Python3, Apache2, mod_wsgi harjoitusta, ja asennetaan Flask.

Flask asennus

$ sudo apt-get update
$ sudo apt-get -y install python3 ipython3 python3-flask curl

HelloWorld ohjelma testausta varten

$ nano moi.py

from flask import Flask
app = Flask(__name__)

@app.route(‘/’)
def hello_world():
return ‘Hello World by Flask at juhaimmonen.com!\n\n’

if __name__ == ‘__main__’:
app.run(host=’178.128.199.241′, port=80)

Luodaan WSGI-ohjelma

$ nano moi.wsgi

import sys

if sys.version_info[0]<3:       # require python3

raise Exception(“Python3 required! Current (wrong) version: ‘%s'” % sys.version_info)

sys.path.insert(0, ‘/home/vagrant/flask/’)
from moi import app as application

Muokataan Virtual Host asetuksia

$ sudoedit /etc/apache2/sites-available/juhawsgi.conf

<VirtualHost *:80>

ServerName juhawsgi.juhaimmonen.com

WSGIScriptAlias / /home/juhawsgi/public_wsgi/moi.wsgi

WSGIDaemonProcess moi user=juhawsgi group=juhawsgi threads=5

<Directory /home/juhawsgi/public_wsgi/>
WSGIProcessGroup moi
WSGIApplicationGroup %{GLOBAL}
WSGIScriptReloading On

Require all granted
</Directory>

</VirtualHost>

Testaus

Ajetaan wsgi-ohjelma: http://juhawsgi.juhaimmonen.com

Internal server error

Apachen error.log:ssa virheilmoitus

:49692] mod_wsgi (pid=22534, process=’moi’, application=”): Failed to parse WSGI script file ‘/home/juhawsgi/public_wsgi/moi.wsgi’.
[Mon Oct 01 13:23:55.127252 2018] [wsgi:error] [pid 22534] [remote
:49692] mod_wsgi (pid=22534): Exception occurred processing WSGI script ‘/home/juhawsgi/public_wsgi/moi.wsgi’.
[Mon Oct 01 13:23:55.132929 2018] [wsgi:error] [pid 22534] [remote
:49692] File “/home/juhawsgi/public_wsgi/moi.wsgi”, line 3
[Mon Oct 01 13:23:55.132952 2018] [wsgi:error] [pid 22534] [remote
:49692] if sys.version_info[0]<3:\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc2\xa0\xc
2\xa0 # require python3

Debugattu virettä python3 konsolissa, ja muutettu sisennyksiä ja kommentin paikkaa moi.wsgi tiedostossa:

import sys

#require python
if sys.version_info[0]<3:

raise Exception(“Python3 required! Current (wrong) version: ‘%s'” % sys$

sys.path.insert(0, ‘/home/juhawsgi/public_wsgi/’)
from moi import app as application

Testattu uudestaan, ja nyt ohjelma toimii. URL: http://juhawsgi.juhaimmonen.com

Testattaessa myös komentoriviltä, ohjelma toimii.

$ curl -sH ‘Host: juhawsgi.juhaimmonen.com’ juhaimmonen.com

Hello World by Flask at juhaimmonen.com!

Koodin muuttamisen testaaminen

Tavoite olisi saada koodiin tehtävät muutokset näkymään ilman Apachen restarttia. Tällöin ei myöskään tarvittaisi sudo-oikeuksia.

Apachen virtual host konfiguraatiossa on rivi, jonka pitäisi mahdollistaa se

WSGIScriptReloading On

Editoidaan moi.py-tiedostoa ja muutetaan tekstiä, jonka ohjelma tulostaa. Eli editoidaan riviä

return ‘Hello World by Flask at juhaimmonen.com!\n\n’

muotoon

return ‘Flask koodia at juhaimmonen.com!\n\n’

Tällä ei kuitenkaan ollut toivottua vaikutusta. Sama vanha teksti näkyy edelleen selaimessa.

Apachen restartin jälkeen tulostuu oikea teksti

Tämän jälkeen muutettu tiedoston moi.wsgi aikaleimaa komennolla touch ja muokattu moi.py:n tulostamaa tekstiä.

moi.py-muutos:

return ‘Flask koodia päivityksen jälkeen juhaimmonen.com!\n\n’

$ touch moi.wsgi (komentoriviltä, muuttaa tiedoston päivityksen aikaleimaa)

Nyt ohjelma toimii kuten pitääkin, ja päivityksiä voi tehdä ilman sudo-oikeuksia. Muutin siis aluksi väärän tiedoston aikaleimaa.

 

 

Ohjelmointikielten kokeilua

Tehtävänä oli kirjoittaa ja suorittaa “Hei maailma” kolmella kielellä, sekä asentaa tarvittavat ympäristöt.

C-kieli

Asennetaan C-kääntäjä gcc

sudo apt-get install gcc

nano hello.c

#include <stdio.h>

int main() {

printf(“Hello, World!\n”);

return 0;

}

käännä ohjelma: gcc hello.c -o hello

Ajettu ohjelma komennolla ./hello

Tulostuu: Hello, World

Java

Asennetaan ajoympäristö: sudo apt-get install default-jre

Testataan komennolla java -version

openjdk version “10.0.2” 2018-07-17
OpenJDK Runtime Environment (build 10.0.2+13-Ubuntu-1ubuntu0.18.04.2)
OpenJDK 64-Bit Server VM (build 10.0.2+13-Ubuntu-1ubuntu0.18.04.2, mixed mode)

Asennetaan käännösympäristö: sudo apt-get install default-jdk

kirjoita ohjelma javac HelloWorld.java

nano javac HelloWorld.java


public class HelloWorld {

public static void main(String[] args) {

System.out.println(“Hello, World”);

}


}

Käännä javac javac HelloWorld.java

Aja ohjelma java HelloWorld.java

Tulostus:
$ javac HelloWorld.java
$ java HelloWorld
Hello, World

Python

Pythonia on testattu WSGI asennuksen yhteydessä, sekä Flask asentamisen yhteydessä.

Flask asennus

Python 3 mod_wsgi