DEV Community: Anass Assim

Kryptor: Simple File Encryption on Linux

Anass Assim — Sun, 11 Oct 2026 11:16:17 +0000

Kryptor is a free, open-source command-line tool for encrypting single files (PDFs, images, documents, anything). It uses modern cryptography (XChaCha20-Poly1305 and Argon2id) and has no settings to misconfigure.

Website: https://www.kryptor.co.uk/
Source: https://github.com/samuel-lucas6/Kryptor
Realeses: https://github.com/samuel-lucas6/Kryptor/releases
Privacy : https://privacytools.io/app/kryptor

Note: Kryptor has not had a public security audit. For extremely sensitive data, consider an audited tool such as VeraCrypt or Cryptomator.

Installation (Ubuntu / Debian / other Linux)

Kryptor is not in the apt repositories, so sudo apt install kryptor will fail. Install it manually:

1. Download

Go to the releases page and download the latest Linux x64 zip (for example kryptor-linux-x64.zip):

https://github.com/samuel-lucas6/Kryptor/releases

The release page also lists checksums and signatures if you want to verify the download.

2. Extract and install

cd ~/Downloads
sudo apt install unzip          # only if unzip is missing
unzip kryptor-linux-x64.zip
chmod +x kryptor
sudo mv kryptor /usr/local/bin/

If the extracted file has a different name, rename it to kryptor when moving it.

3. Check it works

kryptor --help

Usage

Encrypt a file with a passphrase

kryptor -e -p report.pdf

You will be asked to enter a passphrase. The result is a new file, report.pdf.bin. The original file is kept, so delete it yourself if you no longer want the unencrypted copy.

Decrypt a file

kryptor -d -p report.pdf.bin

Enter the same passphrase and the original file is restored.

Encrypt several files or a folder

kryptor -e -p file1.pdf file2.jpg MyFolder

Quick reference

Action	Command
Encrypt with passphrase	`kryptor -e -p file`
Decrypt with passphrase	`kryptor -d -p file.bin`
Show all options	`kryptor --help`

Option names and output file extensions can differ between versions, so check kryptor --help if something does not match.

Important: why `-p`?

Without -p, kryptor -e file uses public-key encryption and needs a key pair, giving this error:

Error: You don't have a default key pair. You can generate one using -g|--generate.

For simple passphrase-based encryption, always add -p.

Security tips

Use a strong passphrase. 5 to 6 random words is a good target. The passphrase matters more than the algorithm.
There is no recovery. If you forget the passphrase, the file cannot be decrypted. Store the passphrase in a password manager.
Test decryption before deleting the original file.
Delete the unencrypted original once you are sure the encrypted copy works. Note that a normal delete does not guarantee the data cannot be recovered from the disk.
Keep backups of your encrypted files.

Alternative: GnuPG (preinstalled on most Linux systems)

# Encrypt
gpg --symmetric --cipher-algo AES256 report.pdf

# Decrypt
gpg --decrypt report.pdf.gpg > report.pdf

Pi-hole Setup Guide: Block Ads on Your Laptop, Phone and PC

Anass Assim — Sun, 11 Oct 2026 10:48:04 +0000

A complete, beginner-friendly guide to running Pi-hole with Docker, connecting your devices to it, testing that it works, fixing common problems, and moving it to a Raspberry Pi later.

Pi-hole is a network-wide ad and tracker blocker. It acts as your DNS server and refuses to resolve the domains that serve ads, so blocking works on every device that uses it, with nothing to install on those devices.

How it works
What you need
Quick start
Part 1: Install Pi-hole with Docker
Part 2: Open the dashboard and verify
Part 3: Find the Pi-hole IP address
Part 4: Connect your devices
Part 5: Test that it works
Troubleshooting
Daily use and maintenance
Moving to a Raspberry Pi
Blocking ads outside your home
Security notes
Limitations
FAQ
Uninstall / undo everything
Useful links

How it works

Every time a device opens a website, it first asks a DNS server to turn the name (like example.com) into an IP address.

Without Pi-hole:   Device  ->  Router DNS / ISP DNS  ->  ad domains resolve normally

With Pi-hole:      Device  ->  Pi-hole  ->  ad domain?  YES -> answers 0.0.0.0 (blocked)
                                                         NO  -> forwards to upstream DNS

Because blocking happens at the DNS level:

It works on phones, laptops, smart TVs and any other device that uses Pi-hole as its DNS server.
Nothing is installed on those devices.
It blocks domains, not individual ads. See Limitations.

What you need

Item	Notes
A computer to run Pi-hole	Laptop for testing, or a Raspberry Pi / mini PC / old PC for permanent use. It must stay on for blocking to work.
Docker	Docker Desktop on Windows and macOS, Docker Engine on Linux.
A home network	All devices on the same Wi-Fi / router.
Router access (optional)	Only needed to cover every device automatically (see Moving to a Raspberry Pi).

Quick start

For people in a hurry. Details are in the parts below.

# 1. Start Pi-hole (one line)
docker run -d --name pihole -p 53:53/tcp -p 53:53/udp -p 8080:80/tcp -e FTLCONF_webserver_api_password=change-me -e FTLCONF_dns_listeningMode=all -v pihole:/etc/pihole --restart unless-stopped pihole/pihole:latest

# 2. Open the dashboard
#    http://localhost:8080/admin

# 3. Find the host IP (example: 192.168.1.70), then set it as the
#    DNS server on every device you want to protect.

# 4. Test
dig @<PIHOLE_IP> doubleclick.net      # should return 0.0.0.0

Part 1: Install Pi-hole with Docker

1.1 Install Docker

Windows / macOS: install Docker Desktop, start it, and wait until it says it is running.
Linux (Debian/Ubuntu): follow the official guide: https://docs.docker.com/engine/install/

Check that Docker works:

docker --version
docker run --rm hello-world

On Linux you may need sudo before docker commands, or add your user to the docker group.

1.2 Start Pi-hole

Option A: one command (simplest)

Run it as one line. Replace change-me with your own password:

docker run -d --name pihole -p 53:53/tcp -p 53:53/udp -p 8080:80/tcp -e FTLCONF_webserver_api_password=change-me -e FTLCONF_dns_listeningMode=all -v pihole:/etc/pihole --restart unless-stopped pihole/pihole:latest

What each part does:

Part	Meaning
`-d`	Run in the background
`--name pihole`	Name of the container
`-p 53:53/tcp -p 53:53/udp`	DNS port (needed so other devices can reach Pi-hole)
`-p 8080:80/tcp`	Web dashboard on port 8080 (avoids conflicts with other web servers)
`FTLCONF_webserver_api_password`	Dashboard password
`FTLCONF_dns_listeningMode=all`	Lets Pi-hole answer devices on your network when running in Docker's default bridge mode
`-v pihole:/etc/pihole`	Saves settings and lists in a Docker volume so they survive updates
`--restart unless-stopped`	Starts Pi-hole again after a reboot

Option B: Docker Compose (recommended for a permanent setup)

Create a file named docker-compose.yml:

services:
  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8080:80/tcp"
    environment:
      TZ: "Etc/UTC"                          # change to your timezone, e.g. Europe/Paris
      FTLCONF_webserver_api_password: "change-me"
      FTLCONF_dns_listeningMode: "all"
    volumes:
      - "./etc-pihole:/etc/pihole"
    restart: unless-stopped

Start it:

docker compose up -d

1.3 Check that it is running

docker ps

You should see a container named pihole with status Up ... (healthy) and ports 53 and 8080 listed.

1.4 Linux: "port 53 already in use"

On some Linux systems (notably Ubuntu), systemd-resolved already listens on port 53. If Docker fails to start with an error about port 53:

sudo mkdir -p /etc/systemd/resolved.conf.d
printf "[Resolve]\nDNSStubListener=no\n" | sudo tee /etc/systemd/resolved.conf.d/pihole.conf
sudo systemctl restart systemd-resolved

Then start the Pi-hole container again. (Debian with NetworkManager usually does not have this problem.)

Part 2: Open the dashboard and verify

Open a browser on the same computer and go to:

   http://localhost:8080/admin

Log in with the password you chose.
You should see the dashboard with Status: Active.

At this point the counters will show 0 queries. That is normal: no device is using Pi-hole yet.

Check that blocking works by asking Pi-hole directly. Replace <PIHOLE_IP> with the IP address from Part 3 (or use 127.0.0.1 on the Pi-hole computer itself):

dig @<PIHOLE_IP> doubleclick.net

The answer section should contain 0.0.0.0. This means the domain is blocked.

On Windows, use nslookup:

nslookup doubleclick.net <PIHOLE_IP>

If you get the 0.0.0.0 answer, Pi-hole itself works. The rest of this guide is about making your devices actually use it.

Part 3: Find the Pi-hole IP address

Devices need the local IP address of the computer running Pi-hole. In this guide it is written as <PIHOLE_IP> (for example 192.168.1.70).

System	Command	Look for
Windows	`ipconfig`	IPv4 Address (Wi-Fi or Ethernet adapter)
macOS	`ipconfig getifaddr en0`	The address printed (use `en1` if `en0` is empty)
Linux	`ip a`	`inet 192.168.x.x` on your Wi-Fi or Ethernet interface

Important: home IP addresses usually change over time (DHCP). If the IP changes, devices pointing to the old one lose DNS. Give the Pi-hole computer a fixed IP with a DHCP reservation in your router settings (look for "DHCP reservation", "Address reservation" or "Static lease").

Part 4: Connect your devices

Two approaches:

Approach	Covers	Effort
A. Per device (this part)	Only the devices you configure	Good for testing
B. On the router	Every device on your network	See Moving to a Raspberry Pi

Make sure each device is on the same Wi-Fi as the Pi-hole computer.

4.1 The Pi-hole computer itself (Linux with NetworkManager)

Show the active connections:

nmcli connection show --active

Set the DNS (replace YOUR_WIFI_NAME with the connection name):

sudo nmcli connection modify "YOUR_WIFI_NAME" ipv4.ignore-auto-dns yes ipv4.dns <PIHOLE_IP> ipv6.ignore-auto-dns yes
sudo nmcli connection up "YOUR_WIFI_NAME"

Verify:

cat /etc/resolv.conf
dig doubleclick.net

resolv.conf should show nameserver <PIHOLE_IP> and dig should report SERVER: <PIHOLE_IP>#53 and answer 0.0.0.0.

If you skip this step, the computer running Pi-hole keeps using the router's DNS and its own browser will not be protected, even though Pi-hole works for other devices.

4.2 Windows

Settings -> Network & internet -> Wi-Fi -> click your network
DNS server assignment -> Edit
Choose Manual, switch IPv4 on
Preferred DNS: <PIHOLE_IP> (leave the alternate empty)
Save, then open a terminal and run:

ipconfig /flushdns

If Windows Firewall asks about Docker on the Pi-hole computer, allow it on private networks.

4.3 macOS

System Settings -> Network -> Wi-Fi -> Details...
DNS tab -> click + and add <PIHOLE_IP>
Remove other DNS servers from the list
OK

4.4 Android

Settings -> Network & internet -> Wi-Fi
Long-press your network -> Modify network -> Advanced options
IP settings: Static
Keep the existing IP address, gateway and prefix length the same
DNS 1: <PIHOLE_IP> and clear DNS 2
Save

Then turn off Private DNS, which would bypass Pi-hole:

Settings -> Network & internet -> Private DNS -> Off

(The exact menu names vary by phone brand.)

Setting a static IP on Android can be fiddly. If you prefer, set the DNS on the router instead (see Moving to a Raspberry Pi).

4.5 iPhone / iPad

Settings -> Wi-Fi -> tap the (i) next to your network
Configure DNS -> Manual
Delete the existing servers and Add Server: <PIHOLE_IP>
Save
On the same screen, turn off Limit IP Address Tracking (iCloud Private Relay) for this network. Private Relay bypasses your DNS.

4.6 Disable browser "secure DNS" (important)

Browsers can send DNS through their own encrypted resolver, skipping Pi-hole completely.

Firefox: Settings -> Privacy & Security -> DNS over HTTPS -> Off
Chrome / Edge / Brave: Settings -> Privacy and security -> Security -> turn off Use secure DNS

Also turn off any VPN while testing, because VPNs usually use their own DNS.

4.7 IPv6 note

If your router also advertises an IPv6 DNS server, some devices will use it instead of Pi-hole. If you see ads still loading or devices missing from the Query Log, try disabling IPv6 on that device's Wi-Fi connection while testing, or ignore automatic IPv6 DNS as in the Linux command above.

Part 5: Test that it works

5.1 Check the dashboard

Open http://<PIHOLE_IP>:8080/admin (or http://localhost:8080/admin on the Pi-hole computer) and browse some websites on your devices.

You should see:

Total Queries going up
Queries Blocked greater than 0 (typically 10-30% on a normal day)
Active clients increasing as you connect more devices

5.2 Check which devices are connected

Dashboard -> Query Log. The client column shows the IP of each device that is using Pi-hole:

Your phone and PC appear as 192.168.x.x
The Pi-hole computer's own queries may appear as 172.17.0.1. That is Docker's internal address and is normal.

5.3 See what was blocked

Click List blocked queries on the dashboard to see exactly which domains were stopped.

5.4 Test from each device

From a PC (Windows, macOS, Linux):

nslookup doubleclick.net <PIHOLE_IP>

The answer should be 0.0.0.0.

From a phone: open this in the phone browser while on the same Wi-Fi:

http://<PIHOLE_IP>:8080/admin

If the dashboard opens, the phone can reach Pi-hole, so any remaining problem is the phone's DNS setting.

Troubleshooting

Quick diagnosis

Symptom	Likely cause	Fix
Dashboard shows 0 queries	No device uses Pi-hole yet	Set DNS on the devices (Part 4), including the Pi-hole computer itself
`dig` shows `SERVER: 192.168.1.1` (your router)	The device still uses the router's DNS	Redo the DNS setting for that device and reconnect Wi-Fi
`dig @<PIHOLE_IP> doubleclick.net` does not return `0.0.0.0`	Pi-hole problem	Check `docker ps` and `docker logs pihole`
No internet after changing DNS	Pi-hole unreachable (Docker stopped, computer asleep, firewall, wrong IP)	Set DNS back to automatic, then check the items in this table
Phone or PC cannot open `http://<PIHOLE_IP>:8080/admin`	Router isolation, different network, or firewall	See Router isolation and Firewall
Dashboard works but a device is missing in Query Log	Device bypasses your DNS	Disable Private DNS / Private Relay / browser secure DNS / VPN / IPv6 DNS
It worked, then stopped	The Pi-hole computer's IP changed or it went to sleep	Check the IP again, set a DHCP reservation, disable sleep
Some ads still show	Normal DNS-level limitation	See Limitations
Error: port 53 already in use	Another service uses port 53	See 1.4

Router isolation

If devices cannot reach the Pi-hole computer at all (the dashboard does not open from the phone or PC):

Log in to your router (often http://192.168.1.1).
Look for AP Isolation, Client Isolation or Guest network and turn isolation off.
Make sure all devices are on the same Wi-Fi network (not a guest network, not mobile data).
Reconnect the devices and test again.

Firewall

On the Pi-hole computer, make sure ports 53 (TCP and UDP) and 8080 (TCP) are reachable from your local network.

Windows: allow Docker on private networks when prompted.
Linux with ufw: check with sudo ufw status. If it says inactive, it is not blocking anything and you can leave it off. If you use it, the correct commands are:

  sudo ufw allow from 192.168.1.0/24 to any port 53
  sudo ufw allow from 192.168.1.0/24 to any port 8080 proto tcp

Replace 192.168.1.0/24 with your own network range.

See whether DNS packets reach the computer (advanced)

sudo apt install tcpdump
sudo tcpdump -ni <INTERFACE> udp port 53 and host <DEVICE_IP>

Browse on the device:

Packets appear: the network path works, so check the Query Log.
Nothing appears: the device is not sending DNS to Pi-hole. Check its DNS settings, Private DNS / Private Relay, VPN, or router isolation.

Useful diagnostic commands

docker ps                       # is the container running and healthy?
docker logs pihole              # Pi-hole logs
docker restart pihole           # restart Pi-hole
cat /etc/resolv.conf            # Linux: which DNS does this computer use?
dig doubleclick.net             # which server answered, and is it 0.0.0.0?

Daily use and maintenance

Update Pi-hole (Docker)

Settings are stored in the volume, so updating does not lose them.

docker pull pihole/pihole:latest
docker rm -f pihole
# run the same "docker run ..." command from Part 1 again

With Docker Compose:

docker compose pull
docker compose up -d

Change the dashboard password

docker exec -it pihole pihole setpassword

(On a Raspberry Pi installed without Docker: sudo pihole setpassword.)

Update the blocklists

Dashboard -> Tools -> Update Gravity, or:

docker exec pihole pihole -g

Add more blocklists

Dashboard -> Lists
Paste the list URL into the address field and click Add
Run Update Gravity (Tools menu)

Start with a few well-maintained lists, for example from The Firebog (the green "tick" lists are the safest). Adding too many aggressive lists breaks websites.

A website is broken (allow a domain)

Dashboard -> Query Log and find the blocked domain
Add it to the allow list, or go to Domains and add it as an allowed domain
Reload the site

You can also pause blocking temporarily with Disable Blocking in the menu.

Back up your settings

Dashboard -> Settings -> Teleporter -> Export. Keep the file somewhere safe. You can import it on a new Pi-hole (for example after moving to a Raspberry Pi).

Common commands

docker stop pihole              # stop
docker start pihole             # start
docker restart pihole           # restart
docker logs -f pihole           # follow the logs

Moving to a Raspberry Pi

A laptop only blocks ads while it is on. A Raspberry Pi (or any always-on device) is better for permanent use.

1. Prepare the Raspberry Pi

Install Raspberry Pi OS Lite with the Raspberry Pi Imager (enable SSH in the settings).
Connect it to your router with an Ethernet cable if possible.
In your router, create a DHCP reservation so the Pi always gets the same IP (for example 192.168.1.50).

2. Install Pi-hole

Either use the same Docker commands as in this guide (install Docker first), or use the official installer:

curl -sSL https://install.pi-hole.net | bash

Follow the wizard:

Pick an upstream DNS provider (Cloudflare, Quad9, etc.)
Keep the default blocklist
Keep the web admin interface enabled

Set the dashboard password:

sudo pihole setpassword

The dashboard is then at http://<PI_IP>/admin.

3. Cover every device: set DNS on the router

Log in to your router.
Find the DHCP or LAN settings with a DNS server field.
Set the primary DNS to the Pi's IP (for example 192.168.1.50).
Leave the secondary DNS empty. If you add a public DNS as a backup, devices may use it and skip Pi-hole.
Save, then reconnect your devices (turn Wi-Fi off and on).

Every device that gets its settings automatically from the router now uses Pi-hole, and you can set your phone and PC back to Automatic DNS.

If your router does not allow changing DNS, you can use Pi-hole's built-in DHCP server instead: disable DHCP on the router and enable it in Pi-hole (Settings -> DHCP). Only do this if you understand the change, because two DHCP servers on one network cause problems.

4. Import your settings (optional)

Export a Teleporter backup from the old Pi-hole and import it on the new one: Settings -> Teleporter.

Blocking ads outside your home

When your phone uses mobile data or another Wi-Fi, it does not talk to the Pi-hole at home. To keep the protection, connect to your home network through a VPN:

Tailscale is the easiest option:
1. Install Tailscale on the Pi-hole computer and on your phone.
2. In the Tailscale admin console go to DNS and add the Pi-hole's Tailscale IP as a custom nameserver.
3. Enable Override local DNS.
4. Make sure Pi-hole answers Tailscale clients (in Docker you already set FTLCONF_dns_listeningMode=all; on a bare-metal install set Settings -> DNS -> Permit all origins).
WireGuard (for example with PiVPN) is a self-hosted alternative.

Do not make Pi-hole reachable directly from the internet (see below).

Security notes

Never port-forward port 53 (or the dashboard) to the internet. An open DNS server can be abused in attacks. Use a VPN instead.
Use a strong dashboard password and do not keep the example password from this guide.
Keep the container image updated.
The dashboard on port 8080 uses plain HTTP and is meant for your home network only.
Pi-hole sees the domains your devices request. Keep its logs private and use the Privacy settings (Settings -> Privacy) to reduce what is stored.

Limitations

Pi-hole is excellent, but it is not magic:

It blocks domains. Ads served from the same domain as the content (for example most YouTube ads) cannot be blocked by DNS alone.
Some apps and devices (smart TVs, some phone apps) use hard-coded DNS and ignore your settings.
Browsers with secure DNS / DNS over HTTPS can bypass Pi-hole unless disabled.
Blocking is not perfect: some ads and trackers may still get through, and aggressive lists can break websites.
If the Pi-hole computer is off, devices that rely on it have no DNS. This is why a stable, always-on device is recommended.

For the best result, combine Pi-hole with a browser extension such as uBlock Origin.

FAQ

Do I need to install anything on my phone?
No. Only change its DNS setting (or set DNS on the router).

Does Pi-hole slow down my internet?
No. Local DNS answers are fast, and cached answers return almost instantly.

Can I use it on Windows or macOS?
Yes, with Docker Desktop. For permanent use a Raspberry Pi or Linux server is better.

Why do I still see ads?
Pi-hole blocks ad domains, not every ad. See Limitations and check that your browser's secure DNS is off.

Why did my internet stop after I set the DNS?
The Pi-hole computer is off, asleep, has a different IP now, or cannot be reached. Set DNS back to automatic and check the Troubleshooting table.

Will it work if I change Wi-Fi networks?
Per-device DNS settings are saved per network. On other networks use a VPN (see Blocking ads outside your home).

Is Pi-hole free?
Yes, it is free and open source.

Uninstall / undo everything

Set DNS back to Automatic on every device you changed (phone, PC, laptop, router).

Linux (NetworkManager):

   sudo nmcli connection modify "YOUR_WIFI_NAME" ipv4.ignore-auto-dns no ipv4.dns "" ipv6.ignore-auto-dns no
   sudo nmcli connection up "YOUR_WIFI_NAME"

Stop and remove the container:

   docker stop pihole
   docker rm pihole

Optionally delete its saved data:

   docker volume rm pihole

(If you used Docker Compose with ./etc-pihole, delete that folder instead.)

Useful links

Pi-hole website: https://pi-hole.net/
Pi-hole documentation: https://docs.pi-hole.net/
Pi-hole Docker image: https://hub.docker.com/r/pihole/pihole
Pi-hole Docker documentation: https://github.com/pi-hole/docker-pi-hole
Docker installation: https://docs.docker.com/get-started/get-docker/
Raspberry Pi Imager: https://www.raspberrypi.com/software/
Tailscale: https://tailscale.com/
PiVPN: https://pivpn.io/
Blocklist collection: https://firebog.net/

Flooky AI : Create tu propia IA

Anass Assim — Fri, 06 Jun 2025 08:54:57 +0000

Tutorial Práctico: Implementación de Flooky AI desde Cero

Este tutorial documenta paso a paso cómo implementar Flooky AI, un chat de IA privado basado en la API de Claude, desde la creación de cuentas hasta el despliegue completo.

📋 Índice

Creación de la cuenta Azure
Configuración del proyecto en Azure DevOps
Creación de los repositorios
Instalación y configuración del agente de pipeline en WSL
Despliegue de la infraestructura con Terraform
Crear y configurar SonarQube localmente
Despliegue de la aplicación Flooky AI
Configuración del dominio y correo electrónico
Configuración de Grafana y alertas en Slack

1. Creación de la cuenta Azure

1.1. Registro en el portal de Azure

Abre portal.azure.com y selecciona "Crear una cuenta gratuita"
Regístrate con tu dirección de correo electrónico personal
Introduce tus datos personales y de facturación
Verifica tu identidad a través de SMS
Proporciona tu tarjeta de crédito para verificación (no habrá cargos iniciales)

1.2. Creación del grupo de recursos

Una vez dentro del portal:

En el panel lateral izquierdo, haz clic en "Grupos de recursos"
Haz clic en "+ Crear"
Completa la información:
- Suscripción: Selecciona tu suscripción
- Grupo de recursos: Anass-rg
- Región: West Europe
Haz clic en "Revisar + crear" y luego en "Crear"

También puedes usar Azure CLI si prefieres la línea de comandos:

az login
az group create --name flooky-ai-rg --location westeurope

2. Configuración del proyecto en Azure DevOps

2.1. Creación de la organización y el proyecto

Accede a dev.azure.com e inicia sesión con la misma cuenta de Microsoft
Crea una nueva organización:
- Haz clic en "New organization"
- Nombra la organización: "FlookyAI"
- Selecciona la ubicación del host: "West Europe"
Dentro de la organización, crea un nuevo proyecto:
- Haz clic en "New project"
- Nombre: FlookyAI
- Visibilidad: Private
- Control de versiones: Git
- Metodología de trabajo: Agile
- Haz clic en "Create project"

2.2. Generación del PAT (Personal Access Token)

Para permitir la conexión del agente de pipeline:

Haz clic en tu avatar en la esquina superior derecha
Selecciona "Personal Access Tokens"
Selecciona "New Token"
Configura el token con:
- Nombre: "FlookyAI-Pipeline-Agent"
- Organización: FlookyAI
- Expiración: 120 días
- Scope: Custom defined
- Agent Pools: Read & manage
- Build: Read & execute
- Code: Read & write
- Service Connections: Read & query
Copia y guarda el token generado en un lugar seguro (solo se muestra una vez)

💡 Nota: Puedes generar más PAT para otras herramientas según sea necesario.

3. Creación de los repositorios

3.1. Repositorio principal FlookyAI

En Azure DevOps, ve a "Repos" > "Files"
Inicializa el repositorio con un README
Crea la aplicación IA en este repositorio

La aplicación está disponible en mi repositorio GitHub. Puedes clonar el repositorio con este comando:

git clone https://github.com/ciscoAnass/Flooky-AI.git

Crea el archivo azure-pipelines.yml para CI/CD:

Configuración Inicial

trigger:
- main

pool:
  name: Default

variables:
  webAppName: 'Flooky-WebApp'
  azureSubscription: 'SC-SlothAI'
  pythonVersion: '3.10'

Explicación:

El pipeline se activa automáticamente cuando hay cambios en la rama main
Se ejecuta en el grupo de agentes predeterminado
Define tres variables importantes: nombre de la app web, la conexión de servicio de Azure, y la versión de Python a usar

Etapa 1: Build

- stage: Build
  displayName: 'Build stage'
  jobs:
  - job: BuildJob
    steps:
    - task: UsePythonVersion@0
      inputs:
        versionSpec: '$(pythonVersion)'
        addToPath: true
      displayName: 'Use Python $(pythonVersion)'

    - script: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
      displayName: 'Install dependencies'

    - task: ArchiveFiles@2
      inputs:
        rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
        includeRootFolder: false
        archiveType: 'zip'
        archiveFile: '$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip'
        replaceExistingArchive: true
      displayName: 'Archive project files'

    - task: PublishBuildArtifacts@1
      inputs:
        pathToPublish: '$(Build.ArtifactStagingDirectory)'
        artifactName: 'drop'
        publishLocation: 'Container'
      displayName: 'Publish artifacts'

Explicación:

Esta etapa prepara el código para el despliegue
Configura el entorno con Python 3.10
Actualiza pip e instala todas las dependencias del proyecto
Crea un archivo ZIP con todos los archivos del proyecto
Publica este ZIP como un "artefacto" llamado "drop" para usarlo en las siguientes etapas

Etapa 2: Analysis

- stage: Analysis
  displayName: 'SonarQube'
  dependsOn: Build
  condition: succeeded()
  jobs:
  - job: SonarQube
    steps:
    - task: UsePythonVersion@0
      inputs:
        versionSpec: '3.x'
        addToPath: true

    - script: |
        pip install -r requirements.txt
        pip install pytest pytest-cov
        pytest --cov=. --cov-report=xml
      displayName: 'Setup and Test'

    - task: SonarQubePrepare@7
      inputs:
        SonarQube: 'SonarQube-Local'
        scannerMode: 'CLI'
        configMode: 'manual'
        projectKey: 'FlookyAI_FlookyAI_acddf0f9-4761-4ebd-ba6b-e2bf470dfcaf'
        projectName: 'FlookyAI'
        extraProperties: |
          sonar.sources=.
          sonar.python.coverage.reportPaths=coverage.xml
          sonar.exclusions=**/*.pyc,**/__pycache__/**,**/tests/**

    - task: SonarQubeAnalyze@7
    - task: SonarQubePublish@7
      inputs:
        pollingTimeoutSec: '300'

Explicación:

Esta etapa analiza la calidad del código usando SonarQube
Solo se ejecuta si la etapa de Build fue exitosa
Configura Python y reinstala las dependencias
Prepara SonarQube con la configuración necesaria para analizar el código Python
Ejecuta las pruebas del proyecto y genera un informe de cobertura
Realiza el análisis de código y publica los resultados en SonarQube
Excluye archivos innecesarios como bytecode de Python y permite enfocarse en el código fuente real

Etapa 3: Deploy

- stage: Deploy
  displayName: 'Deploy stage'
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: DeployJob
    displayName: 'Deploy to Azure Web App'
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          # Deploy to Azure Web App
          - task: AzureWebApp@1
            inputs:
              azureSubscription: '$(azureSubscription)'
              appType: 'webAppLinux'
              appName: '$(webAppName)'
              package: '$(Pipeline.Workspace)/drop/$(Build.BuildId).zip'
              runtimeStack: 'PYTHON|3.10'
              startupCommand: 'pip install -r requirements.txt && pip install gunicorn && gunicorn --bind=0.0.0.0:8000 app:app'
            displayName: 'Deploy to Azure Web App'

Explicación:

Esta etapa despliega la aplicación en Azure Web App
Solo se ejecuta si la etapa de Build fue exitosa
Define que se está desplegando en el entorno de "producción"
Usa la tarea AzureWebApp para subir el archivo ZIP a la aplicación web de Azure
Configura la aplicación para usar Python 3.10 en Linux
Establece un comando de inicio que:
- Instala las dependencias del proyecto
- Instala el servidor web Gunicorn
- Inicia la aplicación usando Gunicorn en el puerto 8000
La aplicación queda desplegada y funcionando en Azure

3.2. Repositorio de infraestructura

En Azure DevOps, crea un nuevo repositorio:
- Haz clic en el nombre del repositorio actual > "New repository"
- Nombre: FlookyAI-Infrastructure
- Tipo: Git
- Añadir README: Marcado
- Haz clic en "Create"
Crea el archivo main.tf:

data "azurerm_resource_group" "rg" {
    name = "Anass-RG"
}

resource "azurerm_service_plan" "anass-webapp-plan" {
  name                = "Flooky-plan"
  location            = data.azurerm_resource_group.rg.location
  resource_group_name = data.azurerm_resource_group.rg.name
  os_type             = "Linux"
  sku_name            = "B2"
}

resource "azurerm_linux_web_app" "FlookyAIWebApp" {
  name                = "Flooky-WebApp"
  resource_group_name = data.azurerm_resource_group.rg.name
  location            = data.azurerm_resource_group.rg.location
  service_plan_id     = azurerm_service_plan.anass-webapp-plan.id

  site_config {
    application_stack {
      python_version = "3.9"
    }
    always_on = true
  }
}

Este archivo Terraform (main.tf) configura recursos en Azure:

Utiliza un grupo de recursos existente llamado "Anass-RG"
Crea un plan de servicio llamado "Flooky-plan" con tipo Linux y SKU B2
Crea una aplicación web Linux llamada "Flooky-WebApp" que:
- Usa el plan de servicio creado anteriormente
- Configura Python 3.9 como entorno de ejecución
- Mantiene la aplicación siempre activa (always on)

En resumen: es un script de infraestructura como código que despliega una aplicación web Python en Azure usando un grupo de recursos existente.

Crea el archivo provider.tf:

terraform {
    required_providers {
        azurerm = {
        source  = "hashicorp/azurerm"
        version = "4.8.0"
        }
    }
    backend "azurerm" {
    }
}

provider "azurerm" {
    features {}
    skip_provider_registration = true
}

Este fragmento de código Terraform configura:

El proveedor de Azure (azurerm) indicando que se usará la versión 4.8.0 del proveedor de HashiCorp
Un backend de estado remoto en Azure (donde Terraform guardará el estado de la infraestructura), aunque los detalles específicos del backend no están definidos en este fragmento
La configuración del proveedor Azure con opciones básicas:
- features {} activa características predeterminadas
- skip_provider_registration = true evita que Terraform intente registrar los proveedores de recursos en Azure

En resumen: este código establece la configuración necesaria para que Terraform pueda conectarse y gestionar recursos en Azure, usando un estado remoto almacenado también en Azure.

Crea el archivo azure-pipelines.yml para CI/CD:

Configuración Inicial

trigger:
- main

pool:
  name: Default

Explicación:

El pipeline se activa automáticamente cuando hay cambios en la rama main
Se ejecuta en el grupo de agentes predeterminado

Paso 1: Instalación de Terraform

- task: TerraformInstaller@1
  inputs:
    terraformVersion: 'latest'
  displayName: 'Instalar Terraform'

Explicación:

Instala la última versión de Terraform en el agente
Esta herramienta es necesaria para ejecutar los comandos de infraestructura como código

Paso 2: Inicialización de Terraform

- task: TerraformTaskV4@4
  inputs:
    provider: 'azurerm'
    command: 'init'
    backendServiceArm: 'SC-SlothAI'
    backendAzureRmResourceGroupName: 'Anass-RG'
    backendAzureRmStorageAccountName: 'flookystorage'
    backendAzureRmContainerName: 'flookycontainer'
    backendAzureRmKey: 'terraform.tfstate'
  displayName: 'Terraform Init'

Explicación:

Inicializa Terraform (terraform init) para preparar el entorno de trabajo
Configura el backend remoto en Azure para guardar el estado de la infraestructura:
- Usa la conexión de servicio 'SC-SlothAI' para autenticarse
- Almacena el estado en el grupo de recursos 'Anass-RG'
- Usa la cuenta de almacenamiento 'flookystorage'
- Guarda el archivo de estado en el contenedor 'flookycontainer'
- Nombra el archivo de estado como 'terraform.tfstate'

Paso 3: Plan de Terraform

- task: TerraformTaskV4@4
  inputs:
    provider: 'azurerm'
    command: 'plan'
    environmentServiceNameAzureRM: 'SC-SlothAI'
  displayName: 'Terraform Plan'

Explicación:

Ejecuta terraform plan para crear un plan de los cambios a realizar
Este paso muestra qué recursos se crearán, modificarán o eliminarán
Usa la conexión de servicio 'SC-SlothAI' para autenticarse con Azure

Paso 4: Aplicación de Terraform

- task: TerraformTaskV4@4
  inputs:
    provider: 'azurerm'
    command: 'apply'
    environmentServiceNameAzureRM: 'SC-SlothAI'
  displayName: 'Terraform Apply'

Explicación:

Ejecuta terraform apply para implementar los cambios en la infraestructura
Este paso crea o actualiza los recursos definidos en los archivos de Terraform
Usa la conexión de servicio 'SC-SlothAI' para autenticarse con Azure
Implementa automáticamente la infraestructura sin intervención manual

4. Instalación y configuración del agente de pipeline en WSL

4.1. Instalación de WSL en Windows

Abre PowerShell como administrador y ejecuta el comando para instalar WSL con Ubuntu:

wsl --install -d Ubuntu

Espera a que se complete la instalación
Cuando se abra la terminal de Ubuntu, crea un usuario y contraseña

4.2. Actualización de Ubuntu e instalación de dependencias

Actualiza los paquetes del sistema:

sudo apt update && sudo apt upgrade -y

Instala las dependencias necesarias:

sudo apt install -y curl git libicu-dev

4.3. Creación del usuario para el agente

Crea un nuevo usuario para el agente:

sudo adduser azagent

Añade el usuario al grupo sudo:

sudo usermod -aG sudo azagent

Cambia al nuevo usuario:

sudo su - azagent

4.4. Descarga e instalación del agente

Crea un directorio para el agente:

mkdir ~/agent && cd ~/agent

Descarga el paquete del agente:

curl -O https://vstsagentpackage.azureedge.net/agent/3.227.2/vsts-agent-linux-x64-3.227.2.tar.gz

Extrae el paquete:

tar zxvf vsts-agent-linux-x64-3.227.2.tar.gz

Ejecuta el script de configuración:

./config.sh

Durante la configuración, proporciona la siguiente información:

URL del servidor: https://dev.azure.com/FlookyAI
PAT: Pega el token que generaste anteriormente
Nombre del pool de agentes: SelfHostedAgents (si no existe, se creará)
Nombre del agente: WSL-Agent-01 (o el nombre que prefieras)

Instala el agente como servicio:

sudo ./svc.sh install azagent

Inicia el servicio:

sudo ./svc.sh start

Verifica que el servicio está en funcionamiento:

sudo ./svc.sh status

4.5. Verificación del agente en Azure DevOps

En Azure DevOps, ve a "Project settings" (icono de engranaje en la parte inferior izquierda)
Selecciona "Agent pools" en el menú lateral
Haz clic en el pool "SelfHostedAgents"
Verifica que tu agente aparece como "Online"

✅ El agente debe aparecer con status "Online" y estar listo para ejecutar jobs

5. Despliegue de la infraestructura con Terraform

5.1. Creación de recursos para el estado de Terraform

Crea un grupo de recursos para el estado de Terraform:

az group create --name tfstate --location westeurope

Crea una cuenta de almacenamiento:

az storage account create --name anassstorage --resource-group tfstate --sku Standard_LRS

Crea un contenedor de blobs:

az storage container create --name tfstate --account-name anassstorage

5.2. Creación de una conexión de servicio en Azure DevOps

En Azure DevOps, ve a "Project settings" > "Service connections"
Haz clic en "New service connection"
Selecciona "Azure Resource Manager"
Selecciona "Service principal (automatic)"
Completa la información:
- Scope level: Subscription
- Subscription: Selecciona tu suscripción
- Resource group: anass-rg
- Service connection name: SC-Flooky
- Grant access to all pipelines: Marcado
Haz clic en "Save"

5.3. Creación y ejecución del pipeline de infraestructura

En Azure DevOps, ve a "Pipelines" > "Pipelines"
Haz clic en "New pipeline"
Selecciona "Azure Repos Git"
Selecciona el repositorio "FlookyAI-Infrastructure"
Selecciona "Existing Azure Pipelines YAML file"
Selecciona "/azure-pipelines.yml"
Revisa el pipeline y haz clic en "Run"

6. Crear y configurar SonarQube localmente

6.1. Instalar SonarQube Server en Ubuntu WSL

Configuración de Requisitos Previos

Primero, preparemos tu entorno Ubuntu WSL:

# Actualiza tu sistema
sudo apt update && sudo apt upgrade -y

# Instala Java 17 (requerido por SonarQube)
sudo apt install openjdk-17-jdk -y

# Verifica la instalación de Java
java -version

# Instala wget y unzip
sudo apt install wget unzip -y

6.2. Instalar y Configurar SonarQube Community Edition

Crear un usuario dedicado para SonarQube

sudo adduser sonarqube
sudo usermod -aG sudo sonarqube

Cambiar al usuario sonarqube

sudo su - sonarqube

Descargar SonarQube Community Edition (última versión LTS)

cd /opt
sudo wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-10.3.0.82913.zip

Extraer SonarQube

sudo unzip sonarqube-10.3.0.82913.zip
sudo mv sonarqube-10.3.0.82913 sonarqube
sudo chown -R sonarqube:sonarqube sonarqube

Configurar SonarQube

Edita el archivo de configuración de SonarQube:

sudo nano /opt/sonarqube/conf/sonar.properties

Agrega estas líneas al archivo de configuración:

# Configuración del servidor web
sonar.web.host=0.0.0.0
sonar.web.port=9000

# Base de datos (usando H2 embebida para simplicidad)
sonar.embeddedDatabase.port=9092

Iniciar SonarQube

Navega al directorio bin de SonarQube:

cd /opt/sonarqube/bin/linux-x86-64

Inicia SonarQube:

./sonar.sh start

Verifica si está en ejecución:

./sonar.sh status

Espera unos minutos a que SonarQube se inicie por completo, luego accede desde tu navegador a: http://localhost:9000

Inicia sesión con admin/admin
Se te pedirá que cambies la contraseña: establece una nueva segura
Completa el asistente de configuración inicial

6.3. Instalar y configurar SonarQube Scanner

Descargar SonarQube Scanner

cd /opt
sudo wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-5.0.1.3006-linux.zip

Extraer el Scanner

sudo unzip sonar-scanner-cli-5.0.1.3006-linux.zip
sudo mv sonar-scanner-5.0.1.3006-linux sonar-scanner
sudo chown -R sonarqube:sonarqube sonar-scanner

Añadir el scanner al PATH

echo 'export PATH="/opt/sonar-scanner/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

6.4. Crear Tu Primer Proyecto

En la interfaz web de SonarQube, haz clic en "Create Project"
Selecciona "Manually"
Introduce:
- Project key: Flooky-AI
- Display name: Flooky AI

Configurar el Proyecto para el Análisis

Ve a la terminal y clona el repositorio de Flooky-AI:

git clone https://fatimaassim20@dev.azure.com/fatimaassim20/FlookyAI/_git/FlookyAI

Crea un archivo sonar-project.properties en la raíz de tu proyecto:

# En el directorio de tu proyecto
nano sonar-project.properties

Agrega este contenido:

sonar.projectKey=Flooky-AI
sonar.projectName=Flooky AI
sonar.projectVersion=1.0
sonar.sources=.
sonar.host.url=http://localhost:9000
sonar.token=TU_TOKEN_GENERADO_AQUÍ

Ejecutar Tu Primer Análisis

# En el directorio de tu proyecto
sonar-scanner

7. Despliegue de la aplicación Flooky AI

7.1. Obtención de la API Key de Claude

Regístrate en la plataforma de Anthropic para obtener acceso a la API de Claude: https://www.anthropic.com/ y solicita acceso a la API
Una vez aprobado, genera una clave API desde el dashboard:
- Tu clave se verá similar a: sk_ant_api_k3y123456789...

Guarda esta clave para utilizarla más adelante

7.2. Almacenamiento de la clave API en Azure Key Vault

En el portal de Azure, busca y selecciona el Key Vault "flooky-ai-kv" creado por Terraform
Ve a "Secrets" > "Generate/Import"
Completa la información:
- Método de carga: Manual
- Nombre: CLAUDE-API-KEY
- Valor: Pega tu clave API de Claude
Haz clic en "Create"

7.3. Creación y ejecución del pipeline de la aplicación

En Azure DevOps, ve a "Pipelines" > "Pipelines"
Haz clic en "New pipeline"
Selecciona "Azure Repos Git"
Selecciona el repositorio "FlookyAI"
Selecciona "Existing Azure Pipelines YAML file"
Selecciona "/azure-pipelines.yml"
Revisa el pipeline y haz clic en "Run"

7.4. Verificación del despliegue

Una vez completado el pipeline, accede al portal de Azure
Busca y selecciona el App Service "flooky-ai"
Haz clic en "Browse" o en la URL para verificar que la aplicación está funcionando

8. Configuración del dominio y correo electrónico

8.1. Compra del dominio en Hostinger

Accede a Hostinger
Busca el dominio "flooky.space" y verifica su disponibilidad
Añade el dominio al carrito y completa el proceso de compra
Una vez adquirido, accede al panel de control de Hostinger

8.2. Configuración del dominio para Azure App Service

En el portal de Azure, accede a tu App Service "flooky-ai"
En el menú lateral, selecciona "Dominios personalizados"
Haz clic en "Añadir dominio personalizado"
Sigue las instrucciones para obtener los registros DNS necesarios
En el panel de control de Hostinger, ve a la sección "DNS / Nameservers"
Añade los registros DNS proporcionados por Azure:
- Registro A para @
- Registro TXT para verificación
Regresa a Azure y completa el proceso de validación y adición del dominio

Comprobamos que todo funciona y visitamos flooky.space

8.3. Configuración de SSL/TLS

En el App Service, ve a "TLS/SSL settings"
Para un certificado gratuito gestionado por Azure:
- Selecciona "Private Key Certificates (.pfx)"
- Haz clic en "Create App Service Managed Certificate"
- Selecciona tu dominio personalizado
- Haz clic en "Create"
Una vez creado el certificado:
- Ve a "SSL bindings"
- Haz clic en "Add SSL Binding"
- Selecciona tu dominio y el certificado
- Haz clic en "Add Binding"
Establece "HTTPS Only" en "On"

8.4. Configuración de Zoho Mail

Accede a Zoho Mail y regístrate
Selecciona "Add an existing domain" e introduce "flooky.space"
Sigue las instrucciones para verificar la propiedad del dominio
Configura los registros MX, SPF, DKIM y DMARC según las instrucciones de Zoho
Crea las cuentas de correo necesarias: hello@flooky.space
Configura las firmas y ajustes adicionales según tus preferencias

9. Configuración de Grafana y alertas en Slack

9.1. Despliegue y Configuración de Grafana con Docker

En el terminal de Ubuntu WSL ejecuta este comando:

docker run -d \
  --name=grafana \
  -p 3000:3000 \
  -v grafana-storage:/var/lib/grafana \
  -e "GF_SECURITY_ADMIN_PASSWORD=Anass@1234" \
  --restart=unless-stopped \
  grafana/grafana:latest

Accede al navegador con este enlace: http://localhost:3000
Ve a "Connection String" y conecta tu cuenta Azure por ahí

9.2. Creación de dashboards

Crea un nuevo dashboard:

Configura paneles para monitorizar:

CPU y memoria del App Service:

Memoria RAM
Tiempo promedio de respuesta
Requests
Data Out
Tráfico de Red

9.3. Configuración de alertas en Slack

Crea un canal en Slack para las alertas (ej. #flooky-ai-alerts)
Instala la aplicación "Incoming WebHooks" en tu workspace de Slack

Configurar grafana.ini

En Grafana:

Ve a Alerting > Notification channels
Haz clic en "New channel"
Configura:
- Name: Slack Alerts
- Type: Slack
- URL: Pega la URL del webhook
Haz clic en "Test" para verificar
Guarda el canal de notificación
Configura reglas de alerta para los paneles importantes

🎉 ¡Felicidades!

Has completado exitosamente la implementación de Flooky AI desde cero. Tu aplicación ahora debería estar:

✅ Desplegada en Azure Web App
✅ Con un dominio personalizado (flooky.space) configurado
✅ Con SSL/TLS habilitado
✅ Integrada con pipelines de CI/CD en Azure DevOps
✅ Con análisis de código en SonarQube
✅ Monitoreada con Grafana
✅ Con alertas configuradas en Slack
✅ Con correo empresarial funcional

📚 Recursos Adicionales

🤝 Contribución

Si encuentras algún error o tienes sugerencias de mejora, no dudes en:

Crear un issue en el repositorio
Enviar un pull request con tus mejoras
Contactar al equipo de desarrollo

📝 Licencia

Este proyecto está bajo la licencia MIT. Consulta el archivo LICENSE para más detalles.

Desarrollado por: Anass Assim
Institución: I.E.S Rodrigo Caro
Curso: Administración de Sistemas Informáticos en Red
Fecha: 2025

📝 Docker Images Cheat Sheet 🚀

Anass Assim — Sat, 08 Mar 2025 02:14:35 +0000

Command	Description
`docker pull nginx`	Pulls the latest Nginx image from Docker Hub.
`docker images`	Lists all Docker images on the local machine.
`docker ps`	Lists all running containers.
`docker run -d nginx:latest`	Runs an Nginx container in detached mode using the latest version.
`docker run -d -p 8080:80 nginx:latest`	Runs Nginx in detached mode and maps port 8080 on the host to port 80 in the container.
`docker run -d -p 8080:80 -p 3000:80 nginx:latest`	Runs Nginx in detached mode and maps multiple ports (8080 and 3000).
`docker ps -a`	Lists all containers (including stopped ones).
`docker exec -it $ID`	Executes a command inside a running container (replace `$ID` with container ID).
`docker rm $(docker ps -aq)`	Removes all stopped containers.
`docker run --name "MyPage" -d -p 8080:80 nginx:latest`	Runs a container named "MyPage" with port mapping.
`cd /home/user/myhtml && docker run --name "MyPage" -v $(pwd):/usr/share/nginx/html:ro -d -p 8080:80 nginx`	Runs a container and mounts the local HTML folder to the container.
`docker exec -it $container_name bash`	Opens a bash shell in the running container (replace `$container_name`).
`docker run --name "copy-of-mypage" --volumes-from "mypage" -d -p 8081:80 nginx`	Runs a new container using the same volumes as "mypage" and maps port 8081.

Tech and Tools I use

Anass Assim — Thu, 31 Oct 2024 22:24:57 +0000

A SysAdmin Essential Toolkit and Workstation Setup

Here’s my toolkit and setup for:

Personal development projects
Work as a Systems Administrator
Collaborative DevOps and security-focused projects

Code & Scripting

I primarily work with Visual Studio Code for coding and scripting. On Linux, I often turn to Sublime Text for a streamlined experience.

Tech Stack :

Primary Tools:

Automation & Infrastructure: Ansible, Docker, Terraform
Scripting: Bash, Python, PowerShell
Databases: MySQL
Security & Monitoring: Wireshark, Zabbix, Nagios
Testing Tools: pytest, Ansible Test

Secondary Tools:

Web: Apache, NGINX
Logging & Monitoring: Prometheus, Grafana
Networking: Cisco Packet Tracer

Some projects call for additional tools and APIs:

Cloud Providers: AWS, Google Cloud
Payment APIs: PayPal, Bizum
CI/CD: Jenkins, GitHub Actions

Providers

Website : www.anass-assim.com
Domain Provider: Hostinger
Hosting Provider : Github
Mail Provider : Zoho

Growth & Networking

For personal and professional growth, I focus on building and sharing secure, reliable tools. You can find my work on platforms like GitHub, Dev.to , Reddit .

Workstation & Setup

Laptop :

CPU: Intel I7-1255U
GPU: NVIDIA GeForce RTX 3060
RAM: 32GB DDR4
Storage: 1TB NVMe SSD + 2TB HDD
Operating System: DUAL BOOT ( Ubuntu 24.04 and Windows 11 )

Accessories

Keyboard: Logitech G213 Prodigy
Mouse: Logitech G203 LIGHTSYNC
Audio: Sony WH-CH720N
Webcam: Logitech C270

Home Server

CPU : Intel Xeon E5-2670
GPU : Nvidia Geforce GTX 1660
RAM : 8GB x 4 = 32GB DDR4
STORAGE : 512GB SSD + 2TB HDD
Case : Cougar Gemini M RGB
Monitor : Lenovo D24-45 24'' + SAMSUNG LS24C310EAUXEN 24''

Mobile

Phone: Iphone 12
Tablet: Samsung Galaxy Tab S7

📝 Git Cheat Sheet 🚀

Anass Assim — Fri, 25 Oct 2024 22:34:51 +0000

📝 First Steps: Start and Configure A Git 🚀

Command	Description
git init	Creates a new Git repository in the current folder.
git config --global -l	Sets or views Git settings, like username and email ,...
git config $option "text"	Sets a Git configuration option to a specified value.

📅 Day-to-Day Work:

Command	Description
git status	Displays the current status of the working directory and staging area.
git add $File_Name	Stages a file for the next commit.
git rm --cached $File_Name	Untrack a file without deleting it locally.
git commit -m "Message"	Records changes to the repository with a descriptive message.
git diff	Displays differences between changes and the last commit.
git log --oneline	Displays a concise summary of commits in a single line.
git checkout $hash	Switches to the specified commit by its hash.
git fetch	Retrieves updates from the remote repository without merging.
git pull	Fetches and merges updates from the remote repository.
git push	Uploads local commits to the remote repository.
git restore $FileName	Restores the specified file to the last committed state.
git blame	Shows line-by-line authorship for each line in a file.
git stash	Temporarily saves changes that are not ready to be committed.
git tag	Creates a marker for a specific commit, often used for releases.

📂 Files:

Command	Description
.gitconfig	File Stores Git settings like username and preferences.
.gitignore	file specifies files and directories for Git to ignore.

SysInfo Script

Anass Assim — Fri, 18 Oct 2024 23:25:15 +0000

SysInfo 🖥️: Track System Information 📊

This script gathers various system information such as disk usage, RAM usage, processes, IP addresses, last login details, SSH login information, and currently logged-in users.

Description 📝

The script utilizes several Linux commands to fetch and calculate system metrics, providing a snapshot of the system's current state.

Prerequisites ⚙️

Before running the script, ensure you have bc installed. If you're using Debian or a Debian-based distribution (like Ubuntu), you can install it with:

sudo apt-get update
 sudo apt-get install bc

Installation 📥

Clone the repository:

 git clone https://github.com/ciscoAnass/SysInfo.git
 cd SysInfo

Make the script executable:

chmod +x SysInfo.sh

Running the Script on Every Terminal Launch (Optional) 🚀

If you want the script to run every time you open a terminal session, you can append the script path to ~/.bashrc using the following command:

echo "~/SysInfo/SysInfo.sh" >> ~/.bashrc

This command appends the path to your script to the end of ~/.bashrc.
After appending, source ~/.bashrc to apply the changes:

source ~/.bashrc

Now, the script will run automatically every time you open a new terminal session.

Creating a Command Alias 🔧

If you want to create a command alias so you can execute the script by simply typing sysinfo, follow these steps:

echo "alias sysinfo='~/SysInfo/SysInfo.sh'" >> ~/.bashrc

-Source ~/.bashrc to apply the changes:*

source ~/.bashrc

Now, you can simply type sysinfo in your terminal to run the script.

Example Output 🖨️

After running the script, you will see output similar to:

System Information of <current_date>

Usage of / :             <DiskPer> of <DiskCapacity>
Memory Usage :           <RAM>%
Memory Swap :            <Swap>%
Total Processes :        <Processes>
Root Processes :         <RootProcesses>
IPv4 address  :         <ipv4>
IPv6 address :          <ipv6>
Last Login :            <lastlog>

<ssh_info>

Logged Users :           <LoggedUsers>

Contributing 🤝

Contributions are welcome! Feel free to fork the repository and submit pull requests.

Bulk Linux Users Creation

Anass Assim — Fri, 18 Oct 2024 23:23:20 +0000

Bulk User Creator (Linux)

Description

This script automates the bulk creation of user accounts on a Linux system. It prompts for the username and the number of users to create. Usernames are generated based on the input and stored in a CSV file. Each user is created with a default password that matches their username.

Requirements

Linux environment
useradd command available
To encrypt the password of the users using mkpasswd , is it necesarry to install whois Packet.

   sudo apt install whois

Installation

Clone the repository:

   git clone https://github.com/ciscoAnass/Bulk-Linux-User.git
   cd Bulk-Linux-User

Make the script executable:

   chmod +x BulkUsers.sh

Creating a Command Alias (Optional but recommended)

Add the following line to your shell configuration file (e.g., ~/.bashrc for bash):

echo "alias bulkuser='sudo ~/Bulk-Linux-User/BulkUsers.sh'" >> ~/.bashrc

Then, apply the changes:

source ~/.bashrc

Usage

Now you can use the bulkuser alias in your terminal to run the script with parameters. Here's how:

To create 7 users with the username "poppy" (You can choose whatever Username you want to create , also numbers):

bulkuser poppy 7

This will generate output similar to:

User : poppy1 , Password : poppy1
User : poppy2 , Password : poppy2
User : poppy3 , Password : poppy3
User : poppy4 , Password : poppy4
User : poppy5 , Password : poppy5
User : poppy6 , Password : poppy6
User : poppy7 , Password : poppy7

Additionally, it will create a UsrAccess-poppy.csv file containing the usernames and passwords.

Verification

To verify that the users have been created correctly, follow these steps:

Check User Accounts: List the last 7 users created on the system to ensure they have been created:

   getent passwd | tail -7 | cut -d: -f1

Notes

Ensure you have the necessary permissions to execute user creation commands (useradd).
Consider security implications when using default passwords.

DHCP Server

Anass Assim — Fri, 18 Oct 2024 22:55:00 +0000

1- Network Setup :

We assume the following network configuration:

Server (Debian 1) - Internal Network: 192.168.1.1/24
Failover (Debian 2) - Internal Network: 192.168.1.2/24
Relay (Debian 3) - 2 Interfaces (Internal Network):
- IP in the Client Network: 192.168.1.3/24
- IP in the Server Network: 192.168.2.1/24
Client (Debian 4) - Internal Network: 192.168.2.10/24

We will assign the IPs to the machines through the file /etc/network/interfaces :

Server :

Failover :

Relay :

Client:

2- Installing Necessary Packages :

Server :

apt update
apt install isc-dhcp-server

Failover :

apt update
apt install isc-dhcp-server

Relay :

apt update
apt install isc-dhcp-relay

Client :

No packages need to be installed on the client, but it is advisable to update the repository.

apt update

3-Connectivity Check :

To check connectivity between the client and server, we usually ping from the client to the server or vice versa.

Now, edit the network configuration file on the client, located at /etc/network/interfaces, and configure the enp0s3 interface in DHCP mode.

3- Server Machine Configuration :

a- /etc/default/isc-dhcp-server :

Edit the file /etc/default/isc-dhcp-server to configure the interface that will listen for client requests, which in this case will be enp0s3.

b- /etc/dhcp/dhcpd.conf :

Now, configure the DHCP service on the server:

Now we need to restart the DHCP service:

systemctl restart isc-dhcp-server
systemctl status isc-dhcp-server

The service should now be active.

4-Failover Machine Configuration :

a- /etc/default/isc-dhcp-server

Just like on the server, we need to edit the file /etc/default/isc-dhcp-server to configure the interface that will listen for client requests, which in this case will be enp0s3.

b- /etc/dhcp/dhcpd.conf

Now, configure the DHCP service on the Failover:

Now we need to restart the DHCP service:

systemctl restart isc-dhcp-server
systemctl status isc-dhcp-server

The service should now be active.

5-Relay Machine Configuration :

*a- Enable Forwarding: *

Edit the file /proc/sys/net/ipv4/ip_forward to allow packet forwarding between network interfaces:

echo '1' > /proc/sys/net/ipv4/ip_forward

b- Client Network:

To make this change persistent after a reboot, edit the file /etc/sysctl.conf and add the following line:

echo "net.ipv4.ip_forward=1" > /etc/sysctl.conf

c- /etc/default/isc-dhcp-relay

In this file, we need to add the IP of the server and the Failover, and set the two interfaces that connect to the client and the server. By default, these are usually “enp0s3” and “enp0s8” in VirtualBox.

6- DHCP Verification:

Part 1: Server Check

We have finished configuring all machines (Server, RELAY, FAILOVER). Now it's time to check if the DHCP works correctly and if the client can obtain a dynamic IP from the server.

Part 2: Failover Check

After verifying that the client can obtain a dynamic IP from the server and everything works correctly, we can turn off the server or stop the isc-dhcp-server service to check if the client can obtain a dynamic IP from the Failover machine.

systemctl stop isc-dhcp-server # On the Server Machine

DEV Community: Anass Assim

Kryptor: Simple File Encryption on Linux

Installation (Ubuntu / Debian / other Linux)

1. Download

2. Extract and install

3. Check it works

Usage

Encrypt a file with a passphrase

Decrypt a file

Encrypt several files or a folder

Quick reference

Important: why -p?

Security tips

Alternative: GnuPG (preinstalled on most Linux systems)

Pi-hole Setup Guide: Block Ads on Your Laptop, Phone and PC

Table of Contents

How it works

What you need

Quick start

Part 1: Install Pi-hole with Docker

1.1 Install Docker

1.2 Start Pi-hole

1.3 Check that it is running

1.4 Linux: "port 53 already in use"

Part 2: Open the dashboard and verify

Part 3: Find the Pi-hole IP address

Part 4: Connect your devices

4.1 The Pi-hole computer itself (Linux with NetworkManager)

4.2 Windows

4.3 macOS

4.4 Android

4.5 iPhone / iPad

4.6 Disable browser "secure DNS" (important)

4.7 IPv6 note

Part 5: Test that it works

5.1 Check the dashboard

5.2 Check which devices are connected

5.3 See what was blocked

5.4 Test from each device

Troubleshooting

Quick diagnosis

Router isolation

Firewall

See whether DNS packets reach the computer (advanced)

Useful diagnostic commands

Daily use and maintenance

Update Pi-hole (Docker)

Change the dashboard password

Update the blocklists

Add more blocklists

A website is broken (allow a domain)

Back up your settings

Common commands

Moving to a Raspberry Pi

1. Prepare the Raspberry Pi

2. Install Pi-hole

3. Cover every device: set DNS on the router

4. Import your settings (optional)

Blocking ads outside your home

Security notes

Limitations

FAQ

Uninstall / undo everything

Useful links

Flooky AI : Create tu propia IA

Tutorial Práctico: Implementación de Flooky AI desde Cero

📋 Índice

1. Creación de la cuenta Azure

1.1. Registro en el portal de Azure

1.2. Creación del grupo de recursos

2. Configuración del proyecto en Azure DevOps

2.1. Creación de la organización y el proyecto

2.2. Generación del PAT (Personal Access Token)

3. Creación de los repositorios

3.1. Repositorio principal FlookyAI

Configuración Inicial

Etapa 1: Build

Etapa 2: Analysis

Etapa 3: Deploy

3.2. Repositorio de infraestructura

Important: why `-p`?