Funkcie (Čo to dokáže?)

• End-to-End šifrovanie (E2EE): Tvoje správy sú šifrované priamo v zariadení. Ani ty ako admin servera si ich (teoreticky) neprečítaš v databáze.
• Federácia: Môj server na IP 10.10.8.5 sa môže (ak to dovolím) prepojiť s ostatnými servermi na svete (napr. matrix.org).
• Mosty (Bridges): Matrix dokáže pomocou doplnkov prepojiť správy z WhatsAppu, Telegramu alebo Signalu do jednej aplikácie.
• Multimédiá: Podpora pre prenos súborov, hlasové správy a video hovory (cez Jitsi alebo LiveKit).
• Synchrónnosť: Môžeš byť prihlásený na mobile, webe aj desktope naraz a všetko sa okamžite synchronizuje.

Minimálne HW požiadavky (Raspberry Pi / Ubuntu)

Matrix (Synapse) je napísaný v Pythone a vie byť celkom „hladný“ na RAM, najmä ak začneš používať federáciu (pripájať sa do veľkých miestností).

Komponent	Minimum (1-5 používateľov)	Odporúčané (pre plynulý chod)
CPU	ARMv7 / ARMv8 (RPi 3 a novšie)	RPi 4 alebo 5 (4 jadrá)
RAM	1 GB (veľmi tesné, treba Swap)	2 GB – 4 GB
Disk	16 GB MicroSD (Class 10)	32 GB+ (ideálne SSD cez USB 3.0)
Sieť	100 Mbps (Ethernet)	1 Gbps Ethernet

Poznámka

Nakoľko tento manuál vznikol po inštalácií a konfigurácií Matrix Chat, tak sa mi odlišujú IP adresy a porty.

Vytvorenie priečinkov

V kontajneroch vytvoríme nový priečinok napr. chat

mkdir chat

Vytvoríme tomto priečinku chat vytvoríme ďalší priečinok s názvom element

mkdir element

Vytvorenie config.janson

v textovom editore vytvoríme config.janson

nano config.janson

Do neho vložíme, IP adresu, na ktorej chceme aby bežala služba

{
  "default_server_config": {
    "m.homeserver": {
      "base_url": "http://10.10.8.5:8008",
      "server_name": "10.10.8.5"
    }
  }
}

Generovanie počiatočnej konfigurácie Synapse

Pred spustením samotného Compose musíme vygenerovať základné konfiguračné súbory Synapse (homeserver.yaml), inak kontajner nenaštartuje správne.

sudo docker run -it --rm \
  -v $(pwd)/data:/data \
  -e SYNAPSE_SERVER_NAME=10.10.8.5 \
  -e SYNAPSE_REPORT_STATS=no \
  matrixdotorg/synapse:latest generate

Výstup:

sudo docker run -it --rm \
> -v $(pwd)/data:/data \
> -e SYNAPSE_SERVER_NAME=10.10.8.5 \
> -e SYNAPSE_REPORT_STATS=no \
> matrixdotorg/synapse:latest generate
[sudo] password for ivan:
Unable to find image 'matrixdotorg/synapse:latest' locally
latest: Pulling from matrixdotorg/synapse
53196b1f47bd: Pull complete
e7f2a93f0c7a: Pull complete
3c389b3eef21: Pull complete
b08101a833d6: Pull complete
ad999efbff48: Pull complete
6a1e34c16502: Pull complete
2bc10f896e2b: Pull complete
338cdf1f8dc0: Pull complete
ddd420bbfc56: Pull complete
fcc2c9933709: Pull complete
Digest: sha256:9d6bef0a269608d4422bbc5a39140f4a7f667802bcdac143eac0f41f80924dcf
Status: Downloaded newer image for matrixdotorg/synapse:latest
Creating log config /data/10.10.8.5.log.config
Setting ownership on /data to 991:991
Generating config file /data/homeserver.yaml
Generating signing key file /data/10.10.8.5.signing.key
A config file has been generated in '/data/homeserver.yaml' for server name '10.10.8.5'. Please review this file and customise it to your needs.

Vytvorenie docker-compose.yaml

Vytvoríme docker-compose.yaml (ja som to chcel zámerne na porte 4000)

services:
  synapse:
    image: matrixdotorg/synapse:latest
    container_name: synapse
    restart: always
    environment:
      SYNAPSE_SERVER_NAME: "10.10.8.5"
      SYNAPSE_REPORT_STATS: "no"
    volumes:
      - ./data:/data
    ports:
      - "8008:8008"

  element:
    image: vectorim/element-web:latest
    container_name: element
    restart: always
    ports:
      - "4000:80"
    volumes:
      - ./element/config.json:/app/config.json

Spustenie docker compose

Potom spustíme príkazok

sudo docker compose up -d

Môžeme sledovať logy

sudo docker logs -f synapse
sudo docker logs -f element

Teraz môžeme ísť na webovú stránku

http://10.10.8.5:4000/

Vytvorenie užívateľa

Keď všetko prebehne v poriadku, vytvoríme užívateľa idealne prveho, ako admin

sudo docker exec -it synapse register_new_matrix_user http://localhost:8008 -c /data/homeserver.yaml

Nevytvárajú sa účty pomocou GUI, ale len pomocou príkazového riadku

Otvoríme si, chat vo webovom prehliadači a klikneme na Invite už vopred vytvoreného užívateľa

Vypisuje sa to v takomto tvare

Verejný chat

Ak chceme mať chat verejný je potrebné urobiť portforwarding. Je potrebné urobiť 2.

• Jedno pravidlo na prístup na webové rozhranie u mňa port 3090
• Druhé, aby sa mohli odosielať správy

Vo fortigate to vyzerá následovne

Potom následne ísť do FireWall Policy

A tu vytvorené pravidla pridať

Potom následne kliknúť na Apply

Potom u poskytovateľa domený je potrebné urobiť A záznam

Upozornenie mobilná aplikácia potrebuje SSL certifikát, inak sa nedokáže pripojiť na server

Začneme s inštaláciou podman

sudo apt update
sudo apt install podman

Ja som rozhodol, že aplikácia bude bežať na porte 3060 a vedel som že budem inštalovať WordPress tak som, ak prvé vytvoril priečinok wordpress

mkdir wordpress

Následne som definoval port

podman pod create --name pod-wp -p 3060:80

Inštalácia databázy

podman run -d --pod pod-wp --name wp-db \
  -e MYSQL_ROOT_PASSWORD=adminheslo \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=moto_user \
  -e MYSQL_PASSWORD=moto_heslo \
  -v ./db_data:/var/lib/mysql:Z \
  docker.io/library/mariadb:latest

Inštalácia WordPress

podman run -d --pod pod-wp --name wp-app \
  -e WORDPRESS_DB_HOST=127.0.0.1 \
  -e WORDPRESS_DB_USER=moto_user \
  -e WORDPRESS_DB_PASSWORD=moto_heslo \
  -e WORDPRESS_DB_NAME=wordpress \
  -v ./wp_data:/var/www/html:Z \
  docker.io/library/wordpress:latest

Následne otvortw webový prehliadač v tvare:

http://X.X.X.X:3060

Spustenie a zastavenie projektov

Vytvorí a spustí všetky kontajnery definované v súbore.

docker compose up

Spustí kontajnery na pozadí (tzv. „detached“ mód), takže môžete ďalej používať terminál.

docker compose up -d

Úplne zastaví a odstráni kontajnery, siete a obrázky definované v súbore. (Dáta vo volume zostanú zachované, ak ich explicitne nezmažeme).

docker compose down

Iba zastaví bežiace kontajnery, ale neodstráni ich.

docker compose stop

Opäť spustí predtým zastavené kontajnery.

docker compose start

Monitorovanie a stav

Zobrazí zoznam kontajnerov patriacich k projektu a ich aktuálny stav (či bežia, alebo spadli).

docker compose ps

Vypíše výstup (logy) zo všetkých služieb.

docker compose logs

Sleduje logy v reálnom čase (veľmi užitočné pri ladení chýb).

docker compose logs -f

Správa zmien a zostavovanie

Zostaví (alebo prebuduje) obrazy (images) podľa inštrukcií v Dockerfile.

docker compose build

Stiahne novšie verzie obrazov z Docker Hubu bez toho, aby hneď reštartoval služby.

docker compose pull

Reštartuje všetky služby (vhodné, ak si zmenil nejakú konfiguráciu v aplikácii, ale nie v samotnom compose súbore).

docker compose restart

Poznámka: Ak používate staršiu verziu Dockera, možno budete musieť písať docker-compose (s pomlčkou). V nových verziách je to už integrované priamo, ako podpríkaz docker compose

Môj syn, má rad niekoľko playlistov, ktoré rád počúva pri uspávaní. Tak som sa rozhodol, nepoužívať youtube, ale vyskúšam urobiť vlastný MP3 prehrávač, ktorý by fungoval online. Zvolil so na to Docker a zadanie bolo následovné:

• Sprístupniť niekoľko playlistov
• pozadie, aby sa menilo každých 5 minút
• playlisty, aby sa dali meniť
• Hudba aby sa dala stišovať, zosiľňovať
• Playlist, aby sa dal zastaviť a znova spustiť.
• Chcel som, aby docker bežal na porte 3030

Postup:

Vytvoril som jeden priečinok pomenovaný matej.

Do neho som vložil 2 priečinky

• MP3
• JPG

Do jpg som nahodil obrázky a do MP3 playlisty, ktoré chcem aby sa dali spúšťať.

Vytvoril som súbory:

• docker-compose.yaml
• index.html
• script.js
• style.css

docker-compose.yaml

version: '3'
services:
  mato-player:
    image: nginx:alpine
    container_name: mato_container
    ports:
      - "3030:80"
    volumes:
      - ./mato:/usr/share/nginx/html
    restart: always

index.html

<!DOCTYPE html>
<html lang="sk">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Mato Player</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <div class="container">
        <h1>🎵 Maťkov playlist</h1>

        <div class="controls-group">
            <label for="music-select">Vyber si zvuk/skladbu:</label>
            <select id="music-select">
                <option value="mp3/Brahms.mp3">Brahms - Uspávanka</option>
                <option value="mp3/mozart.mp3">Mozart - Klasika</option>
                <option value="mp3/voda.mp3">Šum vody</option>
                <option value="mp3/metal.mp3">Metal</option>
                <option value="mp3/vysavac.mp3">Biely šum (Vysávač)</option>
            </select>
        </div>

        <button id="music-btn" class="btn-paused" onclick="toggleMusic()">🎶 Spustiť</button>

        <div class="volume-container">
            <label for="volume-control">Hlasitosť</label>
            <input type="range" id="volume-control" min="0" max="1" step="0.1" value="0.5">
        </div>
    </div>

    <audio id="bg-music" loop>
        <source src="mp3/Brahms.mp3" type="audio/mpeg">
    </audio>

    <script src="script.js"></script>
</body>
</html>

script.js

document.addEventListener('DOMContentLoaded', () => {
    const audio = document.getElementById("bg-music");
    const volumeControl = document.getElementById("volume-control");
    const musicSelect = document.getElementById("music-select");
    const musicBtn = document.getElementById("music-btn");

    // --- 1. ROTÁCIA OBRÁZKOV (každých 5 minút) ---
    const images = [
        'astrobot.jpg', 'astrobot2.jpg', 'gumkaci.jpg', 'gumkaci2.jpg',
        'hlada_sa_nemo.jpg', 'macko_pu.jpg', 'paw_patrol.jpg', 
        'paw-patrol2.jpg', 'smolkovia.jpg'
    ];
    
    let currentImgIndex = Math.floor(Math.random() * images.length);

    const changeBg = () => {
        const imgName = images[currentImgIndex];
        document.body.style.backgroundImage = `url('jpg/${imgName}')`;
        console.log("Pozadie zmenené na: " + imgName);
        currentImgIndex = (currentImgIndex + 1) % images.length;
    };

    changeBg(); // Spustiť hneď
    setInterval(changeBg, 300000); // 300 000 ms = 5 minút


    // --- 2. OVLÁDANIE HUDBY ---
    if (audio && volumeControl) {
        audio.volume = 0.5;
        volumeControl.addEventListener('input', (e) => {
            audio.volume = e.target.value;
        });
    }

    if (musicSelect && audio) {
        musicSelect.addEventListener('change', () => {
            const isPlaying = !audio.paused;
            audio.src = musicSelect.value;
            if (isPlaying) {
                audio.play().catch(e => console.log("Čakám na interakciu..."));
            }
            // Reset tlačidla ak sa zmení skladba počas pauzy
            if (audio.paused) {
                musicBtn.innerText = "🎶 Spustiť: " + musicSelect.options[musicSelect.selectedIndex].text;
            }
        });
    }
});

function toggleMusic() {
    const audio = document.getElementById("bg-music");
    const btn = document.getElementById("music-btn");

    if (audio.paused) {
        audio.play().then(() => {
            btn.innerText = "⏸ Pozastaviť";
            btn.className = "btn-playing";
        }).catch(err => alert("Najprv kliknite niekde na stránku pre povolenie zvuku."));
    } else {
        audio.pause();
        btn.innerText = "🎶 Pokračovať";
        btn.className = "btn-paused";
    }
}

style.css

body {
    margin: 0;
    height: 100vh;
    display: flex;
    justify-content: center;
    align-items: center;
    font-family: 'Arial', sans-serif;
    background-size: cover;
    background-position: center;
    transition: background-image 1.5s ease-in-out; /* Plynulá zmena obrázka */
}

.container {
    background: rgba(0, 0, 0, 0.6);
    padding: 30px;
    border-radius: 20px;
    color: white;
    text-align: center;
    width: 300px;
    backdrop-filter: blur(5px);
    border: 2px solid rgba(255, 255, 255, 0.2);
}

.controls-group { margin: 20px 0; }

select {
    width: 100%;
    padding: 10px;
    border-radius: 10px;
    background: #444;
    color: white;
    border: none;
}

#music-btn {
    width: 100%;
    padding: 15px;
    border-radius: 10px;
    border: none;
    font-weight: bold;
    cursor: pointer;
    color: white;
    font-size: 1rem;
}

.btn-paused { background-color: #d62828; }
.btn-playing { background-color: #28a745; }

.volume-container { margin-top: 20px; }

input[type="range"] { width: 100%; cursor: pointer; }

Spustil som docker

sudo docker-compose up -d

Prípadne, ak je potrebné urobiť zmeny tak je nutné docker zastaviť a znovu spustiť

sudo docker-compose down
sudo docker-compose up -d

Som robil svoju prvú vlastnú webovú aplikáciu určenú, pre odpočet dní a hodín do ďalších Vianoc. Áno, inšpirovala vianočná nálada mojej ženy.

Vymyslel som si zadanie:

• Nastaviť 5 pozadí, ktoré sa budú meniť po 10 minútach
• V pozadí bude hrať vianočná hudba – (Viac playlistov)
• Bude tam možnosť si zvoliť časové pásmo
• Zvoliť si prepočet na dni a hodiny
• Bude možné hudbu zastaviť, stíšiť, znovu spustiť
• Tlačidlo bude buď zelené -(Hudba hrá)
• Tlačidlo bude červené – (hudba nehrá)
• Vyvorenei favicon

Vytvoril som priečinok

mdkir christmas-countdown

Do priečinka som vytvoril textové súbory

• Dockerfile
• docker-compose.yaml
• index.html
• script.js
• style.css
• citaj

A zložky, do ktorých som vložil obrázky a hudbu

• jpg som pomenoval: christmas1.jpg, christmas2.jpg, christmas3.jpg, christmas4.jpg, christmas5.jpg
• mp3 som urobil niekoľko hodinový súbor a pomenoval christmas01.mp3.
• favicon uložil som favicon.png

Ďalej do vytvorených súborov som napísal kódy prostredníctvom buď vim, alebo nano:

Dockerfile

FROM nginx:alpine
# Skopíruj všetky súbory do Nginxu
COPY . /usr/share/nginx/html/
# Tento riadok zabezpečí, že Nginx bude posielať správne hlavičky pre JS
RUN sed -i '/types {/a \    application/javascript js;' /etc/nginx/nginx.conf

docker-compose.yaml

services:
  web:
    image: nginx:alpine
    ports:
      - "3010:80"  # port Vianoce
    volumes:
      - /home/ivan/christmas-countdown:/usr/share/nginx/html:ro
    restart: always

script.js

document.addEventListener('DOMContentLoaded', () => {
console.log("Vianočný web: Plná verzia so všetkými funkciami.");

// --- ELEMENTY ---
const timerDisplay = document.getElementById('timer');
const musicBtn = document.getElementById('music-btn');
const audio = document.getElementById('bg-music');
const playlistSelect = document.getElementById('playlist-select');
const volumeSlider = document.getElementById('volume-slider');
const btnDays = document.getElementById('btn-days');
const btnHours = document.getElementById('btn-hours');
const timezoneSelect = document.getElementById('timezone-select');

// --- 1. NÁHODNÉ POZADIE ---
const backgrounds = ['jpg/christmas1.jpg', 'jpg/christmas2.jpg', 'jpg/christmas3.jpg', 'jpg/christmas4.jpg', 'jpg/christmas5.jpg'];
document.body.style.backgroundImage = `url('${backgrounds[Math.floor(Math.random() * backgrounds.length)]}')`;

// --- 2. HUDBA A PLAYLISTY ---
const updateButtonUI = () => {
    if (!musicBtn) return;
    if (audio.paused) {
        musicBtn.innerText = "🎶 ZAPNÚŤ HUDBU";
        musicBtn.style.setProperty('background-color', '#ff4d4d', 'important');
    } else {
        musicBtn.innerText = "⏸ POZASTAVIŤ";
        musicBtn.style.setProperty('background-color', '#28a745', 'important');
    }
};

// Obsluha tlačidla Play/Pause
musicBtn.addEventListener('click', () => {
    if (!audio.src || audio.src.endsWith('/')) {
        audio.src = playlistSelect.value;
    }
    if (audio.paused) {
        audio.play().then(updateButtonUI).catch(() => alert("Klikni najprv na plochu!"));
    } else {
        audio.pause();
        updateButtonUI();
    }
});

// OPRAVA PREKLIKÁVANIA PLAYLISTOV
playlistSelect.addEventListener('change', () => {
    const wasPlaying = !audio.paused;
    audio.src = playlistSelect.value;
    audio.load();
    if (wasPlaying) {
        audio.play().then(updateButtonUI);
    } else {
        updateButtonUI();
    }
});

// Hlasitosť
if (volumeSlider) {
    audio.volume = volumeSlider.value;
    volumeSlider.addEventListener('input', (e) => {
        audio.volume = e.target.value;
    });
}

// --- 3. ODPOČET A ČASOVÉ PÁSMA ---
let viewMode = 'days'; 

const updateCountdown = () => {
    if (!timerDisplay) return;

    // Funkčné časové pásmo
    const tz = timezoneSelect ? timezoneSelect.value : "Europe/Bratislava";
    const now = new Date(new Date().toLocaleString("en-US", {timeZone: tz}));

    let target = new Date(now.getFullYear(), 11, 24, 0, 0, 0);
    if (now > target) target.setFullYear(target.getFullYear() + 1);

    const diff = target - now;

    if (viewMode === 'days') {
        const d = Math.floor(diff / 86400000);
        const h = Math.floor((diff / 3600000) % 24);
        const m = Math.floor((diff / 60000) % 60);
        const s = Math.floor((diff / 1000) % 60);
        timerDisplay.innerText = `${d}d ${h}h ${m}m ${s}s`;
    } else {
        const hTotal = Math.floor(diff / 3600000);
        const m = Math.floor((diff / 60000) % 60);
        const s = Math.floor((diff / 1000) % 60);
        timerDisplay.innerText = `${hTotal.toLocaleString()}h ${m}m ${s}s`;
    }
};

if (timezoneSelect) timezoneSelect.addEventListener('change', updateCountdown);

btnDays.addEventListener('click', () => {
    viewMode = 'days';
    btnDays.classList.add('active');
    btnHours.classList.remove('active');
    updateCountdown();
});
btnHours.addEventListener('click', () => {
    viewMode = 'hours';
    btnHours.classList.add('active');
    btnDays.classList.remove('active');
    updateCountdown();
});

setInterval(updateCountdown, 1000);
updateCountdown();

// --- 4. SNEŽENIE ---
setInterval(() => {
    const snow = document.createElement('div');
    snow.className = 'snowflake';
    snow.innerHTML = '❄';
    snow.style.left = Math.random() * 100 + 'vw';
    snow.style.animation = `fall ${Math.random() * 3 + 2}s linear forwards`;
    document.body.appendChild(snow);
    setTimeout(() => snow.remove(), 5000);
}, 200);

});

index.html

<!DOCTYPE html>
<html lang="sk">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Vianočný Odpočet — ibasterisk.eu</title>
    <link rel="stylesheet" href="style.css">
    <link rel="icon" type="image/png" href="favicon/favicon.png">
</head>
<body>
    <div id="snow-container"></div>

    <div class="container">
        <h1>🎅 Vianočný Odpočet</h1>

        <div id="countdown">
            <span id="timer">Načítavam...</span>
        </div>

        <div class="view-toggle">
            <button id="btn-days" class="active">Dni</button>
            <button id="btn-hours">Hodiny</button>
        </div>

        <div class="controls-group">
            <label>Časové pásmo:</label>
            <select id="timezone-select">
                <option value="Europe/Bratislava">🇸🇰 Slovensko</option>
                <option value="Asia/Tokyo">🇯🇵 Tokio (Japonsko)</option>
                <option value="Europe/Moscow">🇷🇺 Moskva (Rusko)</option>
                <option value="Australia/Sydney">🇦🇺 Sydney (Austrália)</option>
            </select>
        </div>

        <div class="controls-group">
            <label>Vyber Playlist:</label>
            <select id="playlist-select">
                <option value="mp3/christmas01.mp3">Vianočný Mix 01</option>
                <option value="mp3/buble1.mp3">Michael Bublé 1</option>
                <option value="mp3/buble2.mp3">Michael Bublé 2</option>
                <option value="mp3/top20.mp3">Vianočná Top 20</option>
            </select>
        </div>

        <button id="music-btn" class="btn-stopped">🎶 Zapnúť hudbu</button>

        <div class="volume-container">
            <label>Hlasitosť</label>
            <input type="range" id="volume-slider" min="0" max="1" step="0.1" value="0.5">
        </div>

        <audio id="bg-music" loop></audio>
    </div>

    <script src="script.js"></script>
</body>
</html>

style.css

body {
    margin: 0; padding: 0;
    width: 100vw; height: 100vh;
    display: flex; justify-content: center; align-items: center;
    background-size: cover; background-position: center;
    background-color: #1a1a1a;
    font-family: 'Segoe UI', Arial, sans-serif;
    transition: background-image 2s ease-in-out;
    overflow: hidden;
}

.container {
    background: rgba(0, 0, 0, 0.8);
    backdrop-filter: blur(10px);
    padding: 30px; border-radius: 25px;
    color: white; text-align: center; width: 350px;
    position: relative; z-index: 10;
    box-shadow: 0 10px 30px rgba(0,0,0,0.5);
}

#timer {
    font-size: 2rem; font-weight: bold; color: #ff4d4d;
    display: block; margin: 20px 0;
}

.view-toggle { display: flex; justify-content: center; margin-bottom: 20px; }
.view-toggle button {
    background: #444; color: white; border: none;
    padding: 10px 20px; cursor: pointer; transition: 0.3s;
}
.view-toggle button.active { background: #ff4d4d !important; }
.view-toggle button:first-child { border-radius: 10px 0 0 10px; }
.view-toggle button:last-child { border-radius: 0 10px 10px 0; }

select {
    width: 100%; padding: 12px; border-radius: 10px;
    background: #222; color: white; margin-bottom: 15px; border: 1px solid #444;
}

#music-btn {
    width: 100%; padding: 15px; border-radius: 15px;
    border: none; color: white; font-weight: bold;
    cursor: pointer; text-transform: uppercase;
}

.btn-stopped { background-color: #ff4d4d !important; }
.btn-playing { background-color: #28a745 !important; }

.snowflake {
    position: fixed; top: -10px; color: white !important;
    z-index: 1000; pointer-events: none;
    animation: fall linear forwards;
}

@keyframes fall {
    to { transform: translateY(105vh); }
}

.volume-container input { width: 100%; accent-color: #ff4d4d; margin-top: 10px; 
}

citaj

Tento súbor, nieje dôležitý na koľko sú to len moje poznámky

Následne som spustil kontajner

sudo docker-compose down
sudo docker-compose up --build -d

Kibana je open-source vizualizačný nástroj pre Elasticsearch, ktorý umožňuje prehliadať, analyzovať a vizualizovať dáta pomocou dashboardov, grafov a máp. Je súčasťou Elastic Stack (ELK stack).

Podporované OS

Linux (Ubuntu, Debian, CentOS, RHEL), Windows, macOS

Podpora Docker

Áno, Kibana má oficiálny Docker image, ktorý umožňuje jednoduché spustenie a škálovanie.

Odporúčané HW požiadavky

CPU: 2 jadrá alebo viac RAM: minimálne 4 GB (8 GB pre väčšie nasadenia) Disk: SSD s dostatočnou kapacitou pre logy a indexy Sieť: stabilné pripojenie k Elasticsearch

Aktualizácia OS

sudo apt update
sudo apt upgrade -y

Inštalácia potrebných závislostí

sudo apt install -y ca-certificates curl gnupg lsb-release

Pridanie Docker GPG kľúča

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Pridanie Docker Repozitára

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Inštalácia Docker Engine a Docker compose

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Vytvorenie docker-compose.yml

nano docker-compose.yml

version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.11.1
    container_name: elasticsearch
    environment:
      - node.name=elasticsearch
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es_data:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
    networks:
      - elk

  kibana:
    image: docker.elastic.co/kibana/kibana:8.11.1
    container_name: kibana
    environment:
      ELASTICSEARCH_HOSTS: "http://elasticsearch:9200"
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch
    networks:
      - elk

volumes:
  es_data:
    driver: local

networks:
  elk:
    driver: bridge

Spustenie docker kontajnerov

sudo docker compose up -d

Otvorte webový prehliadač

http://localhost:5601

Enrollment Token získame

sudo docker exec -it elasticsearch bin/elasticsearch-create-enrollment-token -s kibana

Príklad

 sudo docker exec -it elasticsearch bin/elasticsearch-create-enrollment-token -s kibana
WARNING: Owner of file [/usr/share/elasticsearch/config/users] used to be [root], but now is [elasticsearc     h]
WARNING: Owner of file [/usr/share/elasticsearch/config/users_roles] used to be [root], but now is [elasti     csearch]

eyJ2ZXIiOiI4LjExLjEiLCJhZHIiOlsiMTcyLjE4LjAuMjo5MjAwIl0sImZnciI6IjhmYWEzYjlmZmJjMGQ4MGFjMzM1ZGEzZjM4MmFkYW     VhNzg5NmUxYmUyYWZkNzQzZDNhMzJkYjMyNTY0YTZiNGYiLCJrZXkiOiJWY3lHUnBzQjJ3d1RWZWRxZXJBNzp1TWllMmZoQlM5dUc3Vy1n     Um1SLVJBIn0=

Tento token sa vygeneruje len raz a má časové obmedzenie.

Po jeho vložení do Kibany sa dokončí prvotná konfigurácia.

verifikačný kód nájdeme

sudo docker exec -it kibana bin/kibana-verification-code

A necháme ho zbehnúť

Grafana je open-source softvérový nástroj určený na monitorovanie, vizualizáciu a analýzu dát. Slúži na vytváranie prehľadných a interaktívnych dashboardov, ktoré zobrazujú metriky a údaje získané z rôznych dátových zdrojov v reálnom čase. Grafana je využívaná najmä pri monitorovaní systémov, aplikácií, sietí a infraštruktúry.

Aplikácia podporuje inštaláciu na viacerých Linuxových distribúciách a je dostupná aj ako Docker kontajner, čo umožňuje flexibilné nasadenie v rôznych prostrediach.

Podporované platformy a distribúcie

Platforma
Ubuntu
Debian
CentOS / RHEL
Rocky Linux
AlmaLinux
Fedora
openSUSE
Arch Linux
Docker (kontajnerové prostredie)

Hardvérové a systémové požiadavky

Parameter	Minimálne požiadavky	Odporúčané hodnoty
CPU	1 jadro	2 a viac jadier
RAM	512 MB	1–2 GB a viac
Diskový priestor	~200 MB	Podľa objemu dát
Sieťové pripojenie	Základné pripojenie	Stabilné pripojenie
Operačný systém	Linux (64-bit)	Linux (64-bit)

Inštalácia docker-compose

sudo apt update
sudo apt install -y docker.io docker-compose
sudo systemctl enable --now docker

Vytvoríme priečinok Grafana

mkdir ~/grafana
cd ~/grafana

Vytvoríme docker-compose-grafana.yml

nano docker-compose-grafana.yml

Vložíme do súboru

version: "3.9"

services:
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      GF_SECURITY_ADMIN_USER: admin
      GF_SECURITY_ADMIN_PASSWORD: admin

Spustíme kontajner

sudo docker-compose -f docker-compose-grafana.yml up -d

Inštalácia Zabbix

mkdir ~/zabbix
cd ~/zabbix

nano docker-compose-zabbix.yml

version: '3.5'

services:
  mariadb:
    image: mariadb:11.2
    container_name: zabbix-mariadb
    restart: always
    environment:
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbixpass
      MYSQL_ROOT_PASSWORD: rootpass
      TZ: Europe/Bratislava
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_bin
    volumes:
      - db_data:/var/lib/mysql

  zabbix-server:
    image: zabbix/zabbix-server-mysql:latest
    container_name: zabbix-server
    restart: always
    environment:
      DB_SERVER_HOST: mariadb
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbixpass
      ZBX_TIMEZONE: Europe/Bratislava
    ports:
      - "10051:10051"
    depends_on:
      - mariadb

  zabbix-web:
    image: zabbix/zabbix-web-nginx-mysql:latest
    container_name: zabbix-web
    restart: always
    environment:
      DB_SERVER_HOST: mariadb
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbixpass
      ZBX_SERVER_HOST: zabbix-server
      ZBX_SERVER_PORT: 10051
      TZ: Europe/Bratislava
    ports:
      - "8080:8080"

volumes:
  db_data:

Spustíme kontajner

sudo docker-compose -f docker-compose-zabbix.yml up -d

Prihlásenie na Zabbix

Web: http://<IP_SERVERA>:8080

Default login: Admin / zabbix

Update Zabbix

Stiahnutie novej verzie

sudo docker-compose -f docker-compose-zabbix.yml pull

Spustenie update

sudo docker-compose -f docker-compose-zabbix.yml up -d

Prihlásenie na Grafana

Vytvoríte si heslo a následne meno je: Admin/admin potom Vás systém vyzve, aby si heslo zmenili a následne sa ním prihlásite

sudo apt udpate
sudo apt upgrade

Nainštalujte K3s

curl -sfL https://get.k3s.io | sh -

Môžete skontrolovať stav nodov

sudo kubectl get nodes

Výstup:

NAME   STATUS   ROLES                  AGE   VERSION
ivan   Ready    control-plane,master   5s    v1.33.5+k3s1

Konfigurácia kubectl (aby si ho mohol používať bez sudo):

mkdir -p $HOME/.kube
sudo cp /etc/rancher/k3s/k3s.yaml $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Nasadenie Wiki.js

Vytvoríme yaml

nano wikijs.yaml

Skpírujeme do neho

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wikijs-data
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wikijs
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wikijs
  template:
    metadata:
      labels:
        app: wikijs
    spec:
      containers:
      - name: wikijs
        image: requarks/wiki:latest
        env:
        - name: DB_TYPE
          value: "sqlite"
        - name: DB_FILE
          value: "/data/database.sqlite"
        ports:
        - containerPort: 3000
        volumeMounts:
        - name: data
          mountPath: /data
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: wikijs-data
---
apiVersion: v1
kind: Service
metadata:
  name: wikijs-service
spec:
  type: NodePort
  selector:
    app: wikijs
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
      nodePort: 30080

Následne uložíme

Nasadíme Wiki.js

sudo kubectl apply -f wikijs.yaml
sudo kubectl get pods
sudo kubectl get svc

Teraz otvorte webpvý prehliadač a zadajte IP adresu daného servera v tvare:

http://X.X.X.X:30080

Nasadenie WordPress

Vytvoríme yaml

nano wordpress.yaml

Skopírujeme do neho:

# PersistentVolumeClaim pre MariaDB
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mariadb-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
# PersistentVolumeClaim pre WordPress
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wordpress-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
# MariaDB Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mariadb
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mariadb
  template:
    metadata:
      labels:
        app: mariadb
    spec:
      containers:
      - name: mariadb
        image: mariadb:10.11
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "rootpass"
        - name: MYSQL_DATABASE
          value: "wordpress"
        - name: MYSQL_USER
          value: "wpuser"
        - name: MYSQL_PASSWORD
          value: "wppass"
        volumeMounts:
        - name: mariadb-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mariadb-storage
        persistentVolumeClaim:
          claimName: mariadb-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: mariadb
spec:
  selector:
    app: mariadb
  ports:
    - protocol: TCP
      port: 3306
---
# WordPress Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:6.6-php8.2-apache
        env:
        - name: WORDPRESS_DB_HOST
          value: mariadb
        - name: WORDPRESS_DB_NAME
          value: wordpress
        - name: WORDPRESS_DB_USER
          value: wpuser
        - name: WORDPRESS_DB_PASSWORD
          value: wppass
        ports:
        - containerPort: 80
        volumeMounts:
        - name: wordpress-storage
          mountPath: /var/www/html
      volumes:
      - name: wordpress-storage
        persistentVolumeClaim:
          claimName: wordpress-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: wordpress-service
spec:
  type: NodePort
  selector:
    app: wordpress
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30081

Spustenie WordPress

kubectl apply -f wordpress.yaml
kubectl get pods
kubectl get svc

Zadáme IP adresu s portom v tvare:

http://X.X.X.X:30081

Wazuh je open-source bezpečnostný systém na detekciu hrozieb a monitorovanie integrity, ktorý umožňuje zber, analýzu a vizualizáciu bezpečnostných udalostí z počítačov a serverov v reálnom čase.

Pomáha sledovať bezpečnosť a dodržiavanie predpisov, odhaľovať neautorizované zmeny v súboroch, monitorovať sieťovú aktivitu a generovať alarmy pri podozrivej činnosti. Wazuh využíva centralizovaný manažér (Manager), indexovanie logov (OpenSearch) a webový dashboard na prehľadné zobrazovanie alertov.

Používa sa na:

• Monitorovanie integrity súborov a systémov
• Detekciu bezpečnostných hrozieb
• Analýzu logov z rôznych zariadení
• Audit a dodržiavanie bezpečnostných štandardov (napr. GDPR, PCI-DSS)
• Centrálne spravovanie a vizualizáciu bezpečnostných udalostí

Hardvérové požiadavky pre Wazuh Single-Node (Docker)

Komponent	Minimálne	Odporúčané
RAM	4 GB	8 GB alebo viac
CPU	2 jadrá	4 jadrá alebo viac
Disk	20 GB	50 GB alebo viac, SSD odporúčané
Sieť	1 Gbps LAN	1 Gbps alebo vyššia
OS	Ubuntu 24.04 LTS	Ubuntu 24.04 LTS alebo 22.04 LTS

Požiadavky na Docker

• Docker Engine: ≥ 20.x
• Docker Compose: ≥ 1.29 (alebo docker compose plugin v novších verziách)
• Docker musí mať dostatočné práva (odporúčané spúšťať cez sudo alebo pridanie používateľa do skupiny docker)

Požiadavky na disk a úložisko

• Každý Wazuh manager/agent ukladá logy a alerty:
  • Manager + Indexer môžu rýchlo narásť s počtom monitorovaných hostov.
• Odporúča sa SSD disk pre rýchlejšie vyhľadávanie a indexovanie v OpenSearch.
• Odporúčané miesto na Docker volumes: /var/lib/docker/volumes alebo externé úložisko ≥ 50 GB pri strednej infraštruktúre.

Sieťové požiadavky

Port	Použitie
1514 TCP/UDP	Agent → Manager (logy)
1515 TCP	Agent → Manager (registrácia)
443 TCP	Wazuh Dashboard HTTPS
9200 TCP	Wazuh Indexer / OpenSearch

Inštalácia

Urobte update a upgrade

sudo apt update && sudo apt upgrade -y

Nainštalujte vyžadované balíčky

sudo apt install -y git curl apt-transport-https ca-certificates gnupg lsb-release

Nainštzalujte Docker Compose

sudo apt install -y docker.io docker-compose

Povoľtemu, aby sa spúšťal pri boote OS

sudo systemctl enable --now docker

(Voliteľné) povoľte používateľovi spúšťať Docker bez príkazu sudo:

sudo usermod -aG docker $USER

Klonovať Docker Repository Wazuh

cd ~
git clone https://github.com/wazuh/wazuh-docker.git -b v4.14.1
cd wazuh-docker/single-node

Generovanie certifikátov TLS

sudo docker-compose -f generate-indexer-certs.yml run --rm generator

Spustite Wazuh

sudo docker-compose up -d

Otvorte webový prehliadač, a zadajte IP adresu servera na kotrom beží Wazuh

https://X.X.X.X

Defaultné prihlásenie je:

Username: admin
Password: SecretPassword

Úspešné prihlásenie

Nextcloud je cloudové riešenie na ukladanie, zdieľanie a spravovanie súborov.
Umožňuje bezpečný prístup k dokumentom, fotkám, videám a ďalším súborom z ľubovoľného zariadenia s internetom.
Okrem toho podporuje spoluprácu v reálnom čase – editovanie dokumentov, videohovory, chat či kalendáre.
Nextcloud je open-source, takže máte plnú kontrolu nad svojimi dátami a ich bezpečnosťou.
Jednoducho povedané: je to váš vlastný, súkromný cloud, ktorý nahrádza externé služby ako Google Drive alebo Dropbox, s dôrazom na súkromie a flexibilitu.

Komponent	Minimálne požiadavky

OS (operačný systém)

Linux (napr. Ubuntu 20.04/22.04/24.04), Windows Server, macOS

Webový server

Apache ≥ 2.4 alebo Nginx ≥ 1.10

PHP	Verzia 8.1 alebo vyššia, s nasledujúcimi rozšíreniami: gd, curl, mbstring, xml, zip, intl, bcmath, gmp, fileinfo, ctype

Databáza

MySQL/MariaDB ≥ 10.5, PostgreSQL ≥ 12, SQLite (len pre testovanie)

RAM	Minimálne 512 MB (1 GB odporúčané, viac pre veľké inštalácie)

Diskový priestor

Minimálne 500 MB pre inštaláciu + priestor pre súbory používateľov

Pripojenie na internet

Požadované pre aktualizácie, doplnky a synchronizáciu

Docker (ak používať)

Docker Engine ≥ 20 a Docker Compose ≥ 2.0

Podpora súbor a formátov

Typ	Podpora	Poznámky

Video

MP4, WebM, Ogg

Pre iné formáty treba doplnky alebo externé prehrávače

Audio / Hudba

MP3, Ogg, WAV

Prehráva sa priamo v prehliadači, podpora playlistov cez Nextcloud Music

Obrázky

JPG, PNG, GIF, SVG

Miniatury a náhľady sa generujú automaticky

Dokumenty

PDF, DOCX, ODT, XLSX

Pre editáciu v reálnom čase: Collabora Online alebo OnlyOffice

Videohovory (integrované)

Nextcloud Talk

Plne integrované, vhodné pre menšie skupiny

Videohovory (externé)

Jitsi Meet

Možno integrovať cez externý server alebo iframe, zvláda väčšie skupiny a pokročilé funkcie

Doplnky / externé úložiská

YouTube, Dropbox, Google Drive

Integrácia multimédií a súborov z externých služieb

Inštalácia

Urobte update

sudo apt update && sudo apt upgrade -y

Nainštalujte Docker a Docker Compose

sudo apt install -y docker.io
sudo systemctl enable --now docker
sudo usermod -aG docker $USER

Ak chcete, aby sa Docker a vaše kontajnery spúšťali automaticky po reštarte servera,

sudo systemctl enable docker
sudo systemctl start docker

Nainštalujte Docker Compose

sudo apt install -y docker-compose

Vytvorenie súboru Docker Compose pre Nextcloud

mkdir ~/nextcloud && cd ~/nextcloud

Vytvorte súbor docker-compose.yml

nano docker-compose.yml

Do neho skopírujte:

version: '3'

services:
  db:
    image: mariadb:11
    container_name: nextcloud_db
    restart: unless-stopped
    command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW
    environment:
      MYSQL_ROOT_PASSWORD: your_root_password
      MYSQL_PASSWORD: your_password
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
    volumes:
      - db_data:/var/lib/mysql

  app:
    image: nextcloud:latest
    container_name: nextcloud_app
    ports:
      - 8080:80
    restart: unless-stopped
    environment:
      MYSQL_PASSWORD: your_password
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
      MYSQL_HOST: db
    volumes:
      - nextcloud_data:/var/www/html

volumes:
  db_data:
  nextcloud_data:

Spustite NexCloud

docker-compose up -d

Choďte cez webový prehliadač na webovú lokalitu v tvare

http://X.X.X.X:8080

Vypíšte si údaje o administrátorovi

kliknite na install

Potom Vám odporúča ďalšie aplikácie, ktoré Vám nextCloud tiež môže poskytnúť

Úspešne nainštalované

Zabbix je open-source softvér pre monitoring IT infraštruktúry, ktorý umožňuje sledovať servery, siete, aplikácie a cloudové služby. Vďaka open-source licencii je úplne zdarma, flexibilný a prispôsobiteľný potrebám organizácie.

Hlavné možnosti využitia Zabbixu:

1. Monitoring serverov a pracovných staníc – CPU, RAM, disk, procesy.
2. Monitoring sietí a zariadení – switche, routery, firewally, SNMP zariadenia.
3. Monitoring aplikácií a služieb – databázy, webové servery, emailové služby, kontajnery.
4. Vytváranie upozornení a triggerov – Zabbix môže automaticky posielať e-maily, SMS alebo vykonať skript pri problémoch.
5. Dlhodobá analýza a reportovanie – grafy, histórie, reporty dostupnosti a výkonu.
6. Automatizácia a integrácie – API umožňuje prepojiť Zabbix s inými systémami (ticketing, Slack, Grafana).

Hlavné vlastnosti Zabbixu:

Podpora notifikácií, eskalácií a automatizovaných akcií.

Open-source a bez licenčných poplatkov.

Centralizovaný monitoring s agentami alebo agentless prístupom.

Webové rozhranie pre prehľadné grafy a dashboardy.

Škálovateľnosť – vhodný od malých prostredí po veľké dátové centrá.

Minimálne hardvérové požiadavky – Zabbix Server

Veľkosť prostredia	Počet hostov	CPU	RAM	Disk	Poznámky
Malé	do ~100	1–2 vCPU	2–4 GB	20–40 GB (SSD odporúčané)	cca 5 000 položiek
Stredné	100–500	2–4 vCPU	8–16 GB	60–150 GB (SSD)	20–50 000 položiek
Veľké	1000+	8–16+ vCPU	32–64+ GB	200 GB až TB (SSD)	100 000+ položiek

Minimálne požiadavky – Zabbix Frontend (Web UI)

Komponent	Minimálne požiadavky
CPU	1 vCPU
RAM	512 MB – 1 GB
Disk	1 GB
Web server	Nginx alebo Apache
PHP	podľa verzie Zabbix (napr. PHP 8.x)

Minimálne požiadavky – Zabbix Agent

Komponent	Minimálne požiadavky
CPU	~0,1 vCPU (veľmi nízke nároky)
RAM	128–256 MB
Disk	~50 MB
Poznámky	Dá sa spustiť takmer na akomkoľvek systéme

Inštalácia

Nainštalujte Docker

sudo apt update
sudo apt install docker.io docker-compose -y
sudo systemctl enable --now docker

Vytvorte priečinok projektu

mkdir ~/zabbix-docker
cd ~/zabbix-docker

Vytvorte docker-compose.yml

version: '3.5'

services:
  mariadb:
    image: mariadb:11.2
    container_name: zabbix-mariadb
    restart: always
    environment:
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbixpass
      MYSQL_ROOT_PASSWORD: rootpass
      TZ: Europe/Bratislava
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_bin
    volumes:
      - db_data:/var/lib/mysql

  zabbix-server:
    image: zabbix/zabbix-server-mysql:latest
    container_name: zabbix-server
    restart: always
    environment:
      DB_SERVER_HOST: mariadb
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbixpass
      ZBX_TIMEZONE: Europe/Bratislava
    ports:
      - "10051:10051"
    depends_on:
      - mariadb

  zabbix-web:
    image: zabbix/zabbix-web-nginx-mysql:latest
    container_name: zabbix-web
    restart: always
    environment:
      DB_SERVER_HOST: mariadb
      MYSQL_DATABASE: zabbix
      MYSQL_USER: zabbix
      MYSQL_PASSWORD: zabbixpass
      ZBX_SERVER_HOST: zabbix-server
      ZBX_SERVER_PORT: 10051
      TZ: Europe/Bratislava
    ports:
      - "8080:8080"

volumes:
  db_data:

Spustite Zabbix

sudo docker-compose up -d

Choďte na webový prehliadač a zadajte IP adresu daného servera v tvare:

http://X.X.X.X:8080

Defaultný login je:

User: Admin
Password: zabbix

Hardvérové požiadavky – WordPress + Docker (Ubuntu 24.04)

Parameter	Minimálne požiadavky	Odporúčané požiadavky
CPU	1 vCPU	2 vCPU
RAM	1 GB	2–4 GB
Disk	10–15 GB	20–40 GB
OS	Ubuntu 24.04 (64-bit)	Ubuntu 24.04 (64-bit)
Swap	Odporúčaný pri 1 GB RAM	Nie je nutný
Internet	Základné pripojenie	Stabilné pripojenie
Docker	Docker CE + Docker Compose	Docker CE + Compose

Inštalácia

Nainštalujte Docker

sudo apt update
sudo apt install -y ca-certificates curl gnupg

Pridajte Docker oficialne Repozitáre

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Nainštalujte docker

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Povoľte, aby sa docker súštal pri boote OS

sudo systemctl enable --now docker

Vytvorte adresár projektu WordPress

mkdir ~/wordpress-docker
cd ~/wordpress-docker

Vytvorte docker-cmpose.yml

nano docker-compose.yml

Skopírujte do neho:

version: "3.9"

services:
  db:
    image: mariadb:10.6
    container_name: wp-db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wppass
    volumes:
      - db_data:/var/lib/mysql

  wordpress:
    image: wordpress:latest
    container_name: wordpress-site
    ports:
      - "8080:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wppass
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wp_data:/var/www/html
    depends_on:
      - db

  phpmyadmin:
    image: phpmyadmin/phpmyadmin
    container_name: wp-phpmyadmin
    restart: always
    ports:
      - "8081:80"
    environment:
      PMA_HOST: db
      MYSQL_ROOT_PASSWORD: rootpass

volumes:
  db_data:
  wp_data:

Uložte to a spustite

sudo docker-compose up -d

Otvorte webový prehliadač, Cez webové stránky:

http://X.X.X.X:8080 - WordPress
http://X.X.X.X:8081 - phpMyAdmin

Spustenie WordPress

Výber jazykovej mutácie

PHPMyAdmin

defaultné príhlásenie

root
rootpass

Wiki.js je moderný, otvorený a flexibilný wiki systém, ktorý umožňuje tvorbu, správu a zdieľanie dokumentácie a znalostných bázy. Je postavený na Node.js a využíva databázu ako PostgreSQL, MySQL, MariaDB alebo SQLite. Jeho hlavné prednosti sú:

• Moderné rozhranie (react-based UI)
• Podpora Markdown a WYSIWYG editora
• Silná integrácia s autentizačnými systémami (OAuth, LDAP, SAML)
• Možnosť verzovania stránok a rollbacku zmien
• Plná podpora multimédií a rozšírení

Technické parametre

Parameter	Hodnota / odporúčanie
Platforma	Node.js
Podporované DB	PostgreSQL, MySQL, MariaDB, SQLite, MSSQL
Minimálne OS	Linux (Ubuntu 22.04+), Docker
RAM	min. 512 MB (1 GB+ odporúčané)
CPU	1 jadro (viac pre väčšie inštalácie)
Port	3000 (default)
Web server	Vestavěný Node.js server, odporúča sa reverse proxy (Nginx, Caddy, Traefik)
Storage	Min. 1 GB pre databázu a súbory, SSD odporúčané
Docker image	ghcr.io/requarks/wiki:2
Podpora HTTPS	Treba nastaviť cez reverse proxy (Let’s Encrypt, Caddy, Traefik)

Inštalácia

Urobte update

sudo apt update && sudo apt upgrade -y

Nainštalujte docker

sudo apt install -y docker.io

Povoľte službu, aby sa spúšťala pri boote

sudo systemctl enable --now docker

Nainštalujte docker compose

sudo apt install -y docker-compose

Vytvorenie súboru Docker Compose pre Wiki.js

mkdir ~/wikijs && cd ~/wikijs

Vytvorte docker-compose.yml

nano docker-compose.yml

version: '3'

services:
  wikijs:
    image: ghcr.io/requarks/wiki:2
    container_name: wikijs
    restart: always
    ports:
      - "3000:3000"
    environment:
      DB_TYPE: postgres
      DB_HOST: db
      DB_PORT: 5432
      DB_USER: wikijs
      DB_PASS: wikijs_password
      DB_NAME: wikijs
    depends_on:
      - db

  db:
    image: postgres:15
    container_name: wikijs-db
    restart: always
    environment:
      POSTGRES_USER: wikijs
      POSTGRES_PASSWORD: wikijs_password
      POSTGRES_DB: wikijs
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Poznámky:

wikijs_password → toto heslo môžete nahradiť silnejším heslom.

Wiki.js bude bežať na porte 3000.

Spustite Wiki.js

sudo docker-compose up -d

Teraz otvorte cez webový prehliadač lokalitu

http://X.X.X.X:3000

Spustite inštaláciu

Prihláste sa

Rocket.Chat je open-source platforma na tímovú komunikáciu, podobná Slacku alebo Microsoft Teams.
Slúži na chatovanie, zdieľanie súborov, videohovory a spoluprácu v tíme, pričom celý server môžete prevádzkovať lokálne alebo v cloude, takže dáta zostávajú pod Vašou kontrolou.

Kľúčové funkcie:

• Textový chat v kanáloch a súkromných správach
• Video a audio hovory
• Zdieľanie súborov a obrazoviek
• Integrácie s externými službami (GitHub, Jira, atď.)
• Podpora LDAP a Single Sign-On

Systémové požiadavky pre Rocket.Chat

Tabuľka – odporúčaný výkon podľa počtu používateľov

Počet používateľov	RAM (Rocket.Chat + Mongo)	CPU	Disk pre Rocket.Chat	Disk pre MongoDB	Poznámky
1 – 20	2 GB RAM	1–2 vCPU	5 GB	10–20 GB	Ideálne pre malé interné tímy
20 – 50	4 GB RAM	2 vCPU	10 GB	20–40 GB	Bežné malé firmy
50 – 200	8 GB RAM	2–4 vCPU	20 GB	40–80 GB	MongoDB potrebuje viac pamäte
200 – 500	16 GB RAM	4–6 vCPU	30 GB	80–200 GB	Odporúča sa SSD
500+	32 GB RAM+	8+ vCPU	50 GB	200 GB+	Potrebné ladenie a replikácia

Operačný systém

Komponent	Odporúčanie
OS	Ubuntu 22.04 / 24.04
Architektúra	64-bit
Container	Docker + Docker Compose

Rocket.Chat Server

Parameter	Hodnota
CPU	min. 1 vCPU (lepší >2)
RAM	min. 1 GB, odporúčané 2–4 GB
Port	3000/tcp
Disk	~5–10 GB

Inštalácia

sudo apt update
sudo apt install -y ca-certificates curl gnupg

Pridajte Dockerov GPG kľúč a repozitár

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Inštalácia Docker

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Ak chcete, aby sa Docker a vaše kontajnery spúšťali automaticky po reštarte servera, použite tieto príkazy:

sudo systemctl enable docker
sudo systemctl start docker 

Vytvorte adresár pre Rocket.Chat

mkdir -p ~/rocket && cd ~/rocket

Vytvoriť súbor docker-compose.yml

nano docker-compose.yaml

services:
  rocketchat:
    image: registry.rocket.chat/rocketchat/rocket.chat:latest
    restart: unless-stopped
    environment:
      PORT: 3000
      ROOT_URL: http://localhost:3000
      MONGO_URL: mongodb://mongo:27017/rocketchat?directConnection=true
      MONGO_OPLOG_URL: mongodb://mongo:27017/local?directConnection=true
    depends_on:
      - mongo
    ports:
      - "3000:3000"

  mongo:
    image: mongo:6.0
    restart: unless-stopped
    command: >
      mongod --oplogSize 128 --replSet rs0 --bind_ip_all
    volumes:
      - ./data/db:/data/db
      - ./data/oplog:/data/oplog

  mongoinit:
    image: mongo:6.0
    command: >
      bash -c "
      sleep 5;
      mongosh --host mongo:27017 --eval '
        rs.initiate();
      '
      "
    depends_on:
      - mongo

Spustiť Rocket.Chat

sudo docker-compose up -d

Teraz, otvorte webový prehliadač a zajte IP adresu daného servera v tvare

http://X.X.X.X:3000

Zobrazí sa Vám úvodné okno

Tu vytvoríme administrátorské konto

Zvolíme Next a vyplníme údaje o organizácií

V poslednom kroku dáme mail na administrátora

Na mail Vám príde overenie

A môžete pracovať s Rocketchat

Mailcow je open-source balík aplikácií pre správu e-mailových serverov, ktorý umožňuje jednoduchú inštaláciu, konfiguráciu a bezpečnú prevádzku poštových služieb (SMTP, IMAP, POP3) s moderným webovým rozhraním.

Mailcow slúži na efektívnu správu e-mailovej infraštruktúry: poskytuje poštové schránky, filtráciu spamu a vírusov, zabezpečenú komunikáciu cez TLS a správu domén cez prehľadný webový panel.

Technické požiadavky pre Mailcow

Kategória	Požiadavka	Odporúčanie / Poznámka
Procesor (CPU)	min. 1 GHz	Viacjadrový procesor (x86_64 alebo ARM64) pre lepší výkon
Pamäť (RAM)	min. 6 GiB + 1 GiB swap	4 GiB možné len bez antivírusu a indexovania; pre väčšie nasadenie 16 GiB+
Disk	min. 20 GiB (bez e-mailov)	Odporúča sa SSD/NVMe disk kvôli rýchlosti
Architektúra	x86_64 alebo ARM64	ARM64 podporovaný od Docker verzie 24+
Operačný systém	Debian 11–13, Ubuntu 24.04+, AlmaLinux 8/9, Rocky Linux 9	Používajte čistú inštaláciu bez predinštalovaného Dockeru zo snapu
Docker Engine	≥ 24.0.0	Vyžaduje sa funkčný Docker daemon
Docker Compose	≥ 2.0 (plugin alebo standalone)	Spúšťa kontajnery Mailcow stacku
DNS	FQDN, MX, A, AAAA, PTR, SPF, DKIM, DMARC	Nutné pre správne doručovanie a prijímanie e-mailov
Sieť a porty	25, 80, 443, 465, 587, 993, 995, 4190, 53 (TCP/UDP)	Port 25 nesmie byť blokovaný poskytovateľom
IPv4 / IPv6	statická IP adresa odporúčaná	Nutný správny PTR (reverse DNS) záznam
Úložisko e-mailov	závisí od počtu používateľov	Pre desiatky GB pošty použiť väčší disk (napr. 100 GiB+)
Bezpečnosť	Firewall, SSL/TLS certifikáty (Let’s Encrypt)	HTTPS a SMTPS sú nevyhnutné pre bezpečný prenos
Voliteľné komponenty	Antivírus (ClamAV), Antispam (Rspamd), Fulltext (Solr)	Možno vypnúť pre úsporu pamäte
Autentifikácia (MFA)	Podpora TOTP (napr. Google Authenticator, Authy, Bitwarden)	MFA dostupné pre administrátorov aj používateľov webmailu

Priprava PortForwarding

80

TCP

HTTP (overovanie certifikátu Let’s Encrypt)

Web + ACME

443

TCP

HTTPS (administrátorské rozhranie Mailcow, webmail, ActiveSync)

Webový prístup

25

TCP

SMTP

Prichádzajúca pošta z iných poštových serverov

465

TCP

SMTPS (zabezpečený SMTP)

Odchádzajúca pošta (klienti)

587

TCP

Submission (STARTTLS SMTP pre klientov)

Odchádzajúca pošta (klienti)

993

TCP

IMAPS

Prichádzajúca pošta pre klientov

995

TCP

POP3S (voliteľné)

Prichádzajúca pošta pre klientov

4190

TCP

Sieve (správa poštových filtrov)

Voliteľné

53

TCP/UDP

DNS (iba ak Mailcow používa DNS v rámci Dockeru)

Voliteľné

Uptade a Upgrade

Je potrebné urobiť update a Upgrade systéme

sudo apt update && sudo apt upgrade -y

Najjednoduchší spôsob je nainštalovať Docker z oficiálneho repozitára Docker (nie z vstavaného repozitára Ubuntu).

Pridajte oficiálny GPG kľúč a repozitár Dockeru

sudo apt install ca-certificates curl gnupg -y
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Nainštalujte si plugin Docker Engine + Compose

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Overte inštaláciu

docker --version
docker compose version

Príklad

Docker version 27.x.x, build ...
Docker Compose version v2.x.x

Inštalácia Mailcow

Teraz, keď je Docker pripravený, nainštalujte samotný Mailcow.

Nainštalujte git (ak nie je nainštalovaný)

sudo apt install git -y

Klonovanie repozitár Mailcow

cd /opt
sudo git clone https://github.com/mailcow/mailcow-dockerized
cd mailcow-dockerized

Vygeneruj configuračný súbor

sudo ./generate_config.sh

Spustite Mailcowm

sudo docker compose pull
sudo docker compose up -d

Choďte cez mailový server
napr.

https://mail.ibasterisk.eu>

default login je:

Username: admin
Password: moohoo

Je potrebné voliť možnosť Log in as admin

Pridanie domény

Je púotrebné ísť do Email a konfigurácia

Klilnite na Add Domain

Vypíšeme doménu

V spodnej časti budú možnosti

• Add domain only
• Add domain and restart SOGo

Je dôležité zvoliť Add domain and restart SOGo

Vytvorenie nového administrátora

Volíme systém configuration

Add administrator

Vypĺňame username a password, je možné dať aj heslo vygenerovať

Vytvorenie mailového konta

Ideme do E-mail a Configuration

Volíme Add mailbox

Vypíšeme údaje

Prihlasenie sa cez webové rohranie vytvorenou mailovou adresou

Je potrebné vybrať Log in as user

Nastavenie MFA užívateľa

A vieme si vybrať z možností

Two-factor authentification pre administratora

Two-factor authentification je nastavena automaticky pri vytvorení nového administrátora, ak si želáte tieto nasatvenia modifikovať, tak sa to robí v System >> configuration

Vytváranie záznamov

Vytvoril som A záznam na verejnú IP

mail.ibasterisk.eu	1800	A	109.230.12.223

MX záznam

ibasterisk.eu	1800	MX	10 mail.ibasterisk.eu

TXT záznam

ibasterisk.eu	1800	TXT	v=spf1 a mx include:_spf.ibasterisk.eu -all

dmarc

_dmarc.ibasterisk.eu	1800	TXT	v=DMARC1; p=none; pct=100; rua=mailto:p

a vytvoriť dkim

dkim.ibasterisk.eu	1800	TXT	v=DKIM1; p=MIaAutorizačný_kód_vygenerovaný_na_emailovom_serveryIBIjANBgkqhkiG9w0BAQEFA

Ďalšie TXT záznamy, aby prešli na o365

ibasterisk.eu	1800	TXT	v=spf1 a mx include:_spf.ibasterisk.eu -all
ibasterisk.eu	1800	TXT	v=spf1 include:spf.protection.outlook.com
ibasterisk.eu	1800	TXT	v=spf1 ip4:109.230.12.223 include:spf.prot
	

TXT pre gmailNa google

ibasterisk.eu	1800	TXT	v=spf1 ip4:109.230.12.223 include:_spf.google.com ~all

Vysvetlenia

@ do poľa názvu, ktorý bude predstavovať názov hlavnej domény.
v=spf1 označuje, že ide o záznam SPF a verzia je SPF1.
mx znamená, že všetci hostitelia uvedení v záznamoch MX môžu odosielať e-maily pre vašu doménu a všetci ostatní hostitelia sú zakázaní.
~all znamená, že e-maily z vašej domény by mali pochádzať iba z hostiteľov uvedených v zázname SPF. E-maily od iných hostiteľov budú označené, ako sfalšované.

A Záznam určuje, na akú IP adresu bude doména nasmerovaná. Pomocou nastavení a záznamu možno vytvoriť doménu tretieho rádu už existujúcu doméne.
AAAA záznam určuje, akou adresu IPv6 bude doména nasmerovaná. Tu sa pre presmerovanie použije záznam alebo AAAA záznam rozhoduje o nastavení internetových prehliadačov.
CAA Definuje politiku vystavení SSL/TLS certifikátu na zvolenú doménu. Ovplyvňuje certifikačnú autoritu, ktorú možno vystaviť pre vyplnenú doménu certifikátu SSL/TLS.
CNAME slúži k presmerovaniu subdomény na inú doménu. Názov CNAME musí byť vždy vyplnený. Alias ​​sa zadáva vo forme celého názvu domény (napr. mail.ibasterisk.sk).
MX Určuje mailserver, na, ktorý budú smerovať e-maily zaslané na túto doménu. Vždy sa použije celý doménový názov serveru. Ak máte iba jeho IP adresu, nastavte najprv, ako záznam a jeho doménový názov potom vyplňte pole Mailserver.
NS Nastavuje sa nameserver pre konkrétnu subdoménu. Z určeného menného serveru je určené správanie subdomény. Ostatné záznamy DNS sú naďalej brány z nastavení nameserverov na menej.
SRV Pomocou SRV záznamov je možné nájsť server obsluhujúcej vybranú službu v cieľovej doméne. Zvyčajne sú používané vo spojení so štandardizovanými protokolmi, ako sú XMPP, SIP alebo LDAP.
SSHFP Pri použití technológie DNSSEC môžete využívať záznam typu SSHFP pre ukladanie otlačkov verejných kľúčov pre protokol SSH (nemusíte potom overovať otlačok kľúča ručne pri prvom spojení).
TLSA Pri použití technológie DNSSEC môžete využívať záznam typu TLSA pre ukladanie certifikátov SSL použitých na menej.
TXT stačí vložiť do DNS ľubovoľný text. Text môže byť dlhý maximálne 255 znakov. Používa sa napríklad pre podpis odoslaných emailov (DKIM, SPF).

Dark-Mode

A na záver mailcown podporuje Darkmode. Tak nastavuje pri to mesiačiku.

Týmto sa to zapína a vypína 🙂