DEV Community: Anass Assim

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