RobertOps 💻

Instalación de kubernetes utilizando Ansible

Wed, 30 Oct 2024 00:00:00 GMT

:::note Los archivos del proyecto se encuentran en este repositorio :::

Preparación del escenario

Se van a crear 3 máquinas virtuales, 1 actuará de plano de control, y las otras 2 serán nodos. Para crear el escenario se va a usar Vagrant con virtualbox como proveedor, utilizando el siguiente Vagrantfile:

Vagrant.configure("2") do |config|
    config.vm.box = "debian/bookworm64"
    config.vm.box_check_update = false
    config.vm.synced_folder '.', '/vagrant', disabled: true
    config.vm.provider "virtualbox" do |v|
      v.memory = 1024
      v.cpus = 2
    end
    config.vm.define "plano-control" do |pcontrol|
      pcontrol.vm.hostname = "plano-control"
      pcontrol.vm.network "private_network",
        ip: "192.168.56.10"
    end
    config.vm.define "nodo1" do |nodo1|
      nodo1.vm.hostname = "nodo1"
      nodo1.vm.network "private_network",
        ip: "192.168.56.20"
    end
    config.vm.define "nodo2" do |nodo2|
      nodo2.vm.hostname = "nodo2"
      nodo2.vm.network "private_network",
        ip: "192.168.56.30"
    end
  end

Instalación k8s

Para instalar kubernetes se va a utilizar k3s, que se instala siguiendo estos pasos:

en el plano de control:
```
curl -sfL https://get.k3s.io | sh -
```
después se obtiene el token en /var/lib/rancher/k3s/server/node-token

en los nodos:

curl -sfL https://get.k3s.io | K3S_URL=https://[ip plano control]:6443 K3S_TOKEN=[token] sh -

Ansible

sin embargo, nos interesa automatizar dicho proceso ya que haciendo esto permite escalar el número de nodos fácilmente. para ello, se va a usar ansible. Se han configurado los siguientes ficheros.

Inventario

all:
  children:
    planos_control:
      hosts:
        p_nodo: 
          ansible_ssh_host: 192.168.56.10
          ansible_ssh_user: vagrant
          ansible_ssh_private_key_file: ../.vagrant/machines/plano-control/virtualbox/private_key
    trabajadores:
      hosts:
        nodo1: 
          ansible_ssh_host: 192.168.56.20
          ansible_ssh_user: vagrant
          ansible_ssh_private_key_file: ../.vagrant/machines/nodo1/virtualbox/private_key
        nodo2: 
          ansible_ssh_host: 192.168.56.30
          ansible_ssh_user: vagrant
          ansible_ssh_private_key_file: ../.vagrant/machines/nodo2/virtualbox/private_key

  vars:
    token_k3s: ""
    token_k3s_base64: ""
    ip_pcontrol: "192.168.56.10"

Playbook

- hosts: all
  become: true
  tasks:
    - name: Actualizamos el sistema
      apt: update_cache=yes upgrade=yes
    - name: nos aseguramos de que curl esté instalado
      apt:
        pkg: 
          - curl

- hosts: planos_control
  become: true
  tasks:
    # Para que no haya problemas de certificados al usar kubectl, añadimos la IP del plano de control durante la instalación de k3s.
    - name: instalamos k3s
      shell: "curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC='--tls-san {{ ip_pcontrol }}' sh -"
    - name: sacar token
      ansible.builtin.slurp:
        src: "/var/lib/rancher/k3s/server/node-token"
      register: token_k3s_base64
    - name: descodificar token
      ansible.builtin.set_fact:
        token_k3s: "{{ token_k3s_base64.content | ansible.builtin.b64decode | replace('\n', '' ) }}"
    - debug: msg="el token es {{token_k3s}}"

- hosts: trabajadores
  become: true
  tasks:
    - name: instalamos k3s con el token
      shell: "curl -sfL https://get.k3s.io | K3S_URL=https://{{ ip_pcontrol }}:6443 K3S_TOKEN={{ hostvars['p_nodo'].token_k3s }} sh -"

Tras ejecutar el playbook, k3s se habrá instalado correctamente. Podemos comprobarlo con kubectl, primero copiamos la configuración de kubernetes del plano de control a nuestro kubeconfig :

export KUBECONFIG=~/.kube/config
mkdir ~/.kube 2> /dev/null
chmod 600 "$KUBECONFIG"
ssh -i .vagrant/machines/plano-control/virtualbox/private_key vagrant@192.168.56.10 'sudo k3s kubectl config view --raw' > ~/.kube/config

y en el fichero modificamos la ip de localhost por la de la máquina:

sed -i 's/127\.0\.0\.1/192\.168\.56\.10/g' $KUBECONFIG

Finalmente podemos usar kubectl.

kubectl get nodes

Instalación Gitea

Wed, 14 Jun 2023 00:00:00 GMT

Gitea

Gitea es una solución ligera de alojamiento de código gestionada por la comunidad y escrita en Go, tiene las principales características que tiene github, incluyendo actions. Ahora veremos la instalación de gitea en la VPS.

Preparación

En mi caso voy a instalarlo utilizando docker-compose, para ello, y teniendo en cuenta que uso debian, es necesario ejecutar los siguientes comandos:

apt update
apt install -y docker.io docker-compose

Instalación

Para instalarlo, voy a optar por la opción con una base de datos PostgreSQL. Para ello, en un directorio vacío creamos el siguiente fichero docker-compose.yml (cambiando las credenciales, claro):

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:nightly
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=postgres
      - GITEA__database__HOST=db:5432
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=gitea
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3200:3000"
      - "222:22"
    depends_on:
      - db

  db:
    image: postgres:14
    restart: always
    environment:
      - POSTGRES_USER=gitea
      - POSTGRES_PASSWORD=gitea
      - POSTGRES_DB=gitea
    networks:
      - gitea
    volumes:
      - ./postgres:/var/lib/postgresql/data

y lo desplegamos con

docker-compose up -d

Con eso ya se habrían creado los contenedores. Además, para poder entrar en gitea desde fuera de la VPS usando el dominio, vamos a añadir el siguiente proxy inverso al servidor nginx:

server {
    if ($host ~ ^[^.]+\.admichin\.es$) {
        return 301 https://$host$request_uri;
    } # managed by Certbot
        listen 80;
        listen [::]:80;
        server_name gitea.admichin.es;
        return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    ssl    on;
    ssl_certificate /etc/letsencrypt/live/admichin.es-0001/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/admichin.es-0001/privkey.pem; # managed by Certbot

    index index.html index.php index.htm index.nginx-debian.html;
    server_name gitea.admichin.es;

    location / {
            proxy_pass http://localhost:3200;
            include proxy_params;
    }
}

Con esto hecho, si accedemos a gitea.admichin.es por primera vez, se abrirá la página de configuración:

En esta configuración es importante poner el dominio (más abajo, no donde sale en la foto ya que esa es la configuración de la base de datos). Así como establecer la configuración de ssh y el nombre del sitio. Tras finalizar la configuración, o en la misma ya que es una opción, el primer usuario que se cree será el administrador. Con esto ya tendríamos gitea instalado y funcionando.

Actions

Gitea, desde la versión 1.19 permite añadir actions, que son similares a las GitHub actions. Aunque actualicemos a dicha versión, no aparecerán, ya que tenemos que añadir lo siguiente al final del fichero de configuración, que se encuentra en data/gitea/conf/app.ini:

[actions]
ENABLED=true

Una vez activado, aparece la siguiente opción en el apartado de administración:

Para el paso que irá a continuación, vamos a necesitar el token de registro. Para obtenerlo se accede al apartado de Runners y al botón de Create a new Runner:

Runners

Un runner es una máquina que ejecuta las tareas de un workflow de actions. En mi caso voy a utilizar un contenedor como runner dentro de la VPS también, pero hay varios métodos:

En local

Descargamos el binario de https://gitea.com/gitea/act_runner adecuado para nuestro sistema y ejecutamos los siguientes comandos:

./act_runner register --no-interactive --instance <instance> --token <token>

Donde la instancia es la dirección o IP en la que esté alojada Gitea, y el token es el token que hemos obtenido previamente. Tras esto, ejecutamos el runner:

./act_runner daemon

En contenedor

Para ejecutarlo con docker voy a usar docker-compose. para ello, creo un nuevo directorio con el siguiente fichero docker-compose.yml:

version: "3"

services:
  runner:
    image: gitea/act_runner
    restart: always
    volumes:
      - ./data/act_runner:/data
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - GITEA_INSTANCE_URL=instance
      - GITEA_RUNNER_REGISTRATION_TOKEN=token

Al igual que en el caso anterior la instancia es la dirección o IP en la que esté alojada Gitea, y el token es el token que hemos obtenido previamente.

Una vez en ejecución, los runners aparecen de la siguiente manera:

Activar actions

Aunque esté configurado, las actions están desactivadas por defecto en los repositorios. Para activarlas hay que acceder a la configuración, y en el apartado de ajustes avanzados activarlas:

Podemos ver que se ha activado porque aparece el botón de actions en el repositorio, y podemos añadirlas como se añadirían en GitHub:

Enlaces de interés

Despliegue de EKS usando CrossPlane + ArgoCD

Thu, 01 Jun 2023 00:00:00 GMT

Descripción

El objetivo del proyecto es, utilizando Crossplane, desplegar un clúster de eks y luego sobre éste desplegar una aplicación web estática utilizando para ambos casos como apoyo ArgoCD.

A pesar de existir una alternativa de IaC como terraform, se ha decidido usar Crossplane ya que permite utilizar los comandos nativos de kubernetes para gestionar todos sus recursos, al ser una extensión del mismo.

Todos los manifiestos y archivos de configuración se encuentran en el siguiente repositorio.

Pincha aquí para ir directamente a la configuración del escenario realizado o aquí para ir directamente a las demos.

También en la página de los proyectos integrados se pueden encontrar la documentación en formato pdf, la presentación, y el vídeo de demostración:

https://dit.gonzalonazareno.org/gestiona/proyectos/

Objetivos que se quieren conseguir

Los objetivos que se quieren conseguir son los siguientes:

Lograr una mayor comprensión de lo que es Crossplane y sus posibles aplicaciones.
Automatización: La definición de la infraestructura como código y la automatización del proceso de implementación y gestión de la infraestructura permite a los equipos de desarrollo y operaciones centrarse en tareas más importantes y reducir los errores humanos.
Escalabilidad: Otra ventaja de Kubernetes es su capacidad de escalar automáticamente, tanto hacia arriba como hacia abajo, en función de las necesidades del sistema. Al utilizar Crossplane para gestionar la infraestructura de AWS, se pueden aprovechar las capacidades de escalabilidad de AWS y de Kubernetes para garantizar que el sistema siempre tenga los recursos necesarios para funcionar correctamente.
Portabilidad: Al utilizar Crossplane, se puede asegurar que la infraestructura es portátil y se puede mover fácilmente a otras nubes o proveedores de infraestructura en el futuro. Esto permite a las organizaciones evitar el bloqueo de proveedores y aprovechar las ventajas de diferentes proveedores de nube según sea necesario.
Costes: La utilización de una infraestructura basada en la nube puede ser costosa, por lo que es importante asegurarse de que los recursos se utilizan de manera eficiente y se minimizan los costos innecesarios. Al utilizar Crossplane para gestionar la infraestructura de AWS, se puede optimizar el uso de los recursos y evitar pagar por recursos no utilizados.

¿Por qué Crossplane?

La principal ventaja de Crossplane es que, aún existiendo frameworks que permitan desplegar la misma infraestructura, Crossplane traslada esas interacciones a kubernetes, utilizando sus comandos propios y sus métodos. Esto quiere decir que, por ejemplo, habiendo desplegado un clúster en AWS, se crean automáticamente los siguientes objetos de kubernetes enlazados a la api de AWS:

Además, utilizando kubectl podemos obtener aún más información acerca de estos objetos, dentro del propio clúster local:

En la imagen se puede obtener toda la información referente a el objeto indicado, en este caso un nodegroup, y podemos ver, por ejemplo, el rol de nodo que tiene asignado, la región en la que se encuentra, las subredes disponibles…

Aparte de eso, las ventajas que tiene frente el principal competidor, terraform, son:

Ficheros más entendibles (YAML): Crossplane utiliza archivos YAML para definir la infraestructura, lo que los hace más fáciles de entender y leer para los desarrolladores que pueden estar más familiarizados con el formato YAML. Terraform, por otro lado, utiliza su propio lenguaje de configuración llamado HCL (HashiCorp Configuration Language), que puede tener una curva de aprendizaje para aquellos que no están familiarizados con él.
Permite desplegar indistintamente en los proveedores cloud: Crossplane se enfoca en la gestión de la infraestructura multi-nube, lo que significa que permite a los usuarios definir y gestionar recursos en múltiples proveedores de nube utilizando la misma sintaxis de Kubernetes. Terraform también soporta múltiples proveedores de nube, pero requiere la definición de cada recurso utilizando un proveedor de nube específico.
Metodología GitOps: Crossplane está diseñado para trabajar en una metodología GitOps, lo que significa que todas las definiciones de recursos se almacenan en un repositorio Git y los cambios se aplican automáticamente al clúster de Kubernetes utilizando un proceso de integración y entrega continua (CI/CD). Terraform no está diseñado específicamente para trabajar con GitOps, aunque puede integrarse con sistemas de control de versiones como Git para almacenar y gestionar el código de infraestructura.

Fundamentos teóricos y conceptos

Kubernetes

Kubernetes o k8s para acortar, es una plataforma de sistema distribuido de código libre para la automatización del despliegue, ajuste de escala y manejo de aplicaciones. Una de las principales ventajas de Kubernetes es que ofrece una plataforma común para el desarrollo y la producción de aplicaciones. Esto significa que los equipos de desarrollo pueden crear aplicaciones en sus equipos y luego trasladarlas sin problemas a un entorno de producción utilizando las mismas herramientas y procesos. Kubernetes proporciona una capa de abstracción entre la infraestructura subyacente y las aplicaciones que se ejecutan en ella, lo que facilita la portabilidad de las aplicaciones entre diferentes plataformas y proveedores de nube. Además, Kubernetes ofrece características de autoreparación, lo que significa que las aplicaciones pueden recuperarse automáticamente de fallos en tiempo de ejecución, sin necesidad de intervención humana.

Plano de control

El plano de control de Kubernetes es el conjunto de componentes que se encargan de gestionar el estado del clúster y de coordinar todas las operaciones en el mismo. Estos componentes son responsables de tomar decisiones sobre la orquestación y el escalado de los contenedores y aplicaciones en el clúster, y de garantizar que el estado deseado del clúster se mantenga en todo momento.

GitOps

La metodología GitOps es un enfoque para la entrega continua de aplicaciones en la nube que utiliza Git como fuente de verdad para la configuración y la implementación de la infraestructura y las aplicaciones. En la metodología GitOps, todas las definiciones de la infraestructura y las aplicaciones se almacenan en un repositorio Git centralizado. Los cambios en el repositorio Git son automáticamente detectados por una herramienta de despliegue, que se encarga de implementar los cambios en la infraestructura y las aplicaciones.

La metodología GitOps se basa en los principios de la automatización, la colaboración y la transparencia. En primer lugar, la metodología GitOps

Automatización de la gestión de la infraestructura y las aplicaciones, lo que permite la implementación continua de cambios en un entorno controlado y seguro.
Colaboración entre los miembros del equipo, ya que todos los cambios se realizan en el repositorio Git centralizado, lo que permite a los miembros del equipo trabajar en conjunto de manera más eficiente.
Transparencia, ya que todos los cambios y versiones se registran en el repositorio Git centralizado, lo que permite a los miembros del equipo revisar y rastrear el historial de cambios.

ArgoCD

Argo CD es una herramienta de entrega continua (Continuous Delivery) y de operaciones de infraestructura (Infrastructure Operations) que se ejecuta en Kubernetes. Permite la automatización y el control del proceso de implementación y despliegue de aplicaciones en un clúster de Kubernetes.

Una de las características más destacadas de Argo CD es su capacidad para automatizar la gestión de versiones y el despliegue de aplicaciones. Permite la definición de flujos de trabajo (workflows) para la implementación de cambios, lo que garantiza que los cambios se realicen de manera controlada y segura. Argo CD también incluye características de seguridad, como el control de acceso basado en roles y la autenticación de usuarios.

Infraestructura como código

Es una práctica que consiste en definir la infraestructura de una aplicación o sistema de forma programática utilizando un lenguaje de programación o una sintaxis específica. En lugar de configurar manualmente servidores, redes y otros recursos de infraestructura, los desarrolladores y los equipos de operaciones pueden definir la infraestructura como código y utilizar herramientas de automatización para gestionar y desplegar la infraestructura en un entorno reproducible y escalable.

Crossplane

Crossplane es una extensión de kubernetes que transforma kubernetes en un plano de control Universal. Permite a los usuarios utilizar cualquier API como si fuera nativa de Kubernetes. Esto se logra mediante el uso de los recursos personalizados de Kubernetes (CRD), que permiten a los desarrolladores definir y extender los recursos de Kubernetes con sus propias definiciones. Puede crear y gestionar recursos que no son nativos de Kubernetes, como bases de datos, servicios de almacenamiento en la nube, cuentas de usuario y cualquier otra cosa que una API pueda ofrecer.

Además, Crossplane es compatible con múltiples proveedores de nube, lo que significa que los usuarios pueden utilizar cualquier servicio de cualquier proveedor de nube, incluidos Amazon Web Services, Google Cloud Platform y Microsoft Azure, entre otros. Esto permite a los usuarios crear aplicaciones que utilizan servicios de varios proveedores de nube sin tener que preocuparse por la complejidad de gestionar múltiples APIs de nube diferentes.

Proveedor

Un proveedor de Crossplane le permite aprovisionar una infraestructura en un servicio externo. se utiliza, entre otras cosas, para la autenticación, la realización de llamadas a API externas y utilizando APIs de kubernetes.

Para utilizar un proveedor además, es necesaria una configuración. Ésta se realiza por medio del uso de providerConfig. Normalmente se utilizan para autenticarse con la API con la que se está comunicando, En este proyecto, se utilizan tanto con las credenciales de AWS como con el clúster de EKS.

Escenario realizado

El escenario consiste en lo siguiente:

Clúster local de kubernetes, en el que se han instalado las siguientes aplicaciones:
- ArgoCD
- Crossplane, con los proveedores de AWS y Kubernetes.
Clúster de EKS creado y gestionado por Crossplane, en el que hay 3 nodos.

Instalaciones

Para la realización del proyecto, se necesita instalar los siguientes recursos:

Clúster local de kubernetes

Para desplegar un clúster local de k8s, se usará kind, ya que el proveedor de aws de crossplane consume muchos recursos, y kind es más liviano. Para su instalación se seguirá la documentación oficial: Instalación kind. Para gestionar el clúster también es necesario kubectl, y la documentación oficial de instalación es la siguiente: instalación kubectl. Es muy importante partir de un clúster nuevo y sin configuraciones previas.

ArgoCD

Para instalar ArgoCD se ejecutan los siguientes comandos:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Para acceder a la página de administración, necesito la contraseña inicial. Se obtiene con el siguiente comando; el usuario es admin:

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d;echo

Y para acceder a la página, se realiza el siguiente port-forward:

kubectl port-forward svc/argocd-server -n argocd 8080:80 --address=0.0.0.0

Tras eso ya está configurado ArgoCD.

Crossplane

Para instalar crossplane utilizamos helm

helm repo add \
crossplane-stable https://charts.crossplane.io/stable
helm repo update

helm install crossplane \
crossplane-stable/crossplane \
--namespace crossplane-system \
--create-namespace

Configuración

AWS

Es necesaria una cuenta con los permisos de AWS para crear y gestionar los siguientes recursos:

instancias EC2
clúster de EKS
redes VPC
Tokens de acceso a la propia cuenta Una vez se disponga de dicha cuenta, creamos el token en el siguiente apartado:

credenciales de seguridad > crear clave de acceso > seleccionamos el cuadro y crear clave de acceso > descargar archivo.csv

Proveedores de Crossplane

AWS

Ahora instalamos la última versión del provider de AWS de crossplane

cat <<EOF | kubectl apply -f -
apiVersion: pkg.crossplane.io/v1
kind: Provider
metadata:
  name: provider-aws
spec:
  package: xpkg.upbound.io/crossplane-contrib/provider-aws:v0.39.0
EOF

Tras eso, creamos el fichero aws-credentials.txt con las claves generadas en AWS con el siguiente formato:

[default]
aws_access_key_id = <aws_access_key>
aws_secret_access_key = <aws_secret_key>

Creamos un secret de kubernetes con las credenciales

kubectl create secret \
generic aws-creds \
-n crossplane-system \
--from-file=creds=./aws-credentials.txt

Finalmente, se crea un providerconfig con el secret que hemos creado

cat <<EOF | kubectl apply -f -
apiVersion: aws.crossplane.io/v1beta1
kind: ProviderConfig
metadata:
  name: default
spec:
  credentials:
    source: Secret
    secretRef:
      namespace: crossplane-system
      name: aws-creds
      key: creds
EOF

kubernetes

Instalamos el proveedor con el siguiente comando:

cat <<EOF | kubectl apply -f -
apiVersion: pkg.crossplane.io/v1
kind: Provider
metadata:
  name: crossplane-provider-kubernetes
spec:
  package: crossplane/provider-kubernetes:main
EOF

Recursos gestionados

Para desplegar un clúster de aws de forma sencilla, se van a utilizar dos recursos gestionados (managed resources):

eks.yaml, de tipo composition que contiene parámetros para la creación del clúster, como lo son las redes que se crearán, en qué servidores, qué tipo de máquinas pueden crearse, etc..
definition.yaml, de tipo compositeResourceDefinition, contiene los parámetros que se le van a pasar con el manifiesto final, así como los recursos a los que corresponden en composition. También contiene valores por defecto.

Ambos ficheros se encuentran en el repositorio del proyecto en la carpeta crossplane: https://github.com/robertorodriguez98/proyecto-integrado/tree/main/crossplane

Para añadirlos, se utiliza kubectl:

kubectl apply -f eks.yaml && kubectl apply -f definition.yaml

Ngrok

Para que ArgoCD esté atento a los commits de github y siga así la metodología GitOps, al tenerlo instalado en un clúster local, es necesario instalar ngrok, exponiendo el puerto 8080:

curl -s https://ngrok-agent.s3.amazonaws.com/ngrok.asc | sudo tee /etc/apt/trusted.gpg.d/ngrok.asc >/dev/null && echo "deb https://ngrok-agent.s3.amazonaws.com buster main" | sudo tee /etc/apt/sources.list.d/ngrok.list && sudo apt update && sudo apt install ngrok

Añadimos el token:

ngrok config add-authtoken [TOKEN]

y exponemos el puerto:

ngrok http https://localhost:8080

Webhook

Para que GitHub notifique a ArgoCD en el evento de un push al repositorio, tenemos que añadirlo en la configuración del mismo. Para hacerlo, en el repositorio accedemos al apartado Settings; en la barra lateral seleccionamos Webhooks y Add webhook.

Dentro de la página, tenemos que rellenar los siguientes campos:

Payload URL: la url generada por Ngrok, con la cadena /api/webhook añadida al final.
Content type: application/json.
Event: Cuando se produce un

Preparación previa a la demo

Para preparar la demo, iniciaremos la aplicación de argocd app.yaml que se encuentra en el repositorio, ésta despliega el siguiente manifiesto:

apiVersion: prodready.cluster/v1alpha1
kind: ClusterClaim
metadata:
  name: proyecto-eks
  labels:
    cluster-owner: robertorm
spec:
  id: proyecto-eks
  compositionSelector:
    matchLabels:
      provider: aws
      cluster: eks
  parameters:
    nodeSize: medium
    minNodeCount: 3

Donde podemos modificar los siguientes parámetros:

name: Nombre del clúster.
nodesize: tipo de máquina que se van a utilizar en los nodos. En el fichero eks.yaml se establecen los siguientes tamaños:
- small: t2:micro
- medium: t3.micro
- large: t3.medium
Los dos primeros tamaños, entran dentro de la capa gratuita de AWS.
minNodeCount: mínimo de nodos que tienen que crearse en el clúster.

Tras aproximadamente 15 minutos, el clúster estará creado junto a sus nodos. Si observamos el panel de ArgoCD de la aplicación, podemos ver todos los recursos de AWS que se han desplegado:

Demostraciones

Modificación del número de nodos

El escenario final de la demo es el siguiente:

Y el flujo de trabajo en el que consiste la primera demo, con el clúster ya desplegado es el siguiente:

Se realiza un commit a github con un cambio en el manifiesto aws-eks.yaml, concretamente se cambia el número de nodos que va a tener el clúster de EKS.
ArgoCD se da cuenta de que se han realizado cambios en el repositorio, y, aplicando la metodología gitops, hace que en los recursos que gestiona se vean reflejados dichos cambios. Compruebo que en el panel de la aplicación se ve reflejado el cambio en el recurso nodegroup.
Crossplane, haciendo uso del provider de AWS, se comunica con la API referente a EKS, e indica que el número de nodos ha cambiado.
Finalmente, en AWS se hacen efectivos los cambios, por lo que podemos comprobarlo accediendo a la consola de EKS y viendo el nuevo nodo.

Tras ello, para demostrar el funcionamiento de Crossplane, y como este asegura que se siga el marco de trabajo GitOps, se añade un nodo desde la consola de AWS, mostrando como Crossplane lo detecta y vuelve a dejarlo como está definido en los recursos.

Despliegue en el clúster

Una vez con el clúster, se va a desplegar una aplicación sobre él, utilizando también crossplane. El escenario es el siguiente:

Configuración del proveedor de kubernetes

Para configurar el proveedor de kubernetes para que tenga acceso al clúster que acabamos de crear, se ejecutan los siguientes comandos; Primero obtenemos el kubeconfig y lo guardamos en un fichero:

kubectl --namespace crossplane-system \
    get secret proyecto-eks-cluster \
    --output jsonpath="{.data.kubeconfig}" \
    | base64 -d >kubeconfig.yaml

Enviamos el contenido del fichero a la variable KUBECONFIG:

KUBECONFIG=$(<kubeconfig.yaml)

Usando la variable, creamos un secret que pueda usar el proveedor:

kubectl -n crossplane-system create secret generic cluster-config --from-literal=kubeconfig="${KUBECONFIG}"

Ahora, añadimos la configuración del proveedor usando el secret (el fichero está en la raiz del repositorio). El archivo es: config-kubernetes.yaml:

kubectl apply -f config-kubernetes.yaml

Script

Para facilitar la ejecución de la demo, se ha creado el script configurar-k8s.sh que aúna los pasos anteriores.

Aplicación de ArgoCD

Una vez realizados los pasos anteriores, solo queda desplegar la aplicación. Para ello se va a volver a utilizar ArgoCD; en este caso se va a utilizar la aplicación despliegue-remoto.yaml. Una vez desplegado, se ve así en ArgoCD

para obtener la dirección en la que está la aplicación desplegada (gracias al loadbalancer) se utiliza el siguiente comando:

kubectl describe object loadbalancer-aplicacion-remoto

O si queremos la dirección directamente:

kubectl describe object loadbalancer-aplicacion-remoto | egrep "Hostname"

En la captura el comando es "k" ya que tengo un alias para el comando kubectl.

Finalmente, si accedemos a la dirección podemos visualizar la aplicación desplegada:

Dificultades encontradas

Despliegue sobre AWS

Las principales dificultades que se han encontrado a la hora de desplegar sobre AWS son las siguientes:

Falta de documentación/ejemplos: Al tratarse de una tecnología relativamente nueva y con una comunidad todavía en crecimiento, no ha sido fácil encontrar ejemplos que aplicaran la api de AWS para desplegar específicamente sobre EKS.
Múltiples proveedores: A la hora de elegir el proveedor en el marketplace, resulta que para Amazon Web Services existen dos diferentes, y en la documentación, dependiendo de la versión que se esté consultando, usan uno u otro, teniendo éstos diferentes métodos y llamadas.Se ha utilizado finalmente el siguiente, debido a que hay más documentación sobre él: https://marketplace.upbound.io/providers/crossplane-contrib/provider-aws/v0.39.0
Coste: El uso de EKS no se encuentra dentro de la capa gratuita de AWS, por lo que desplegar un clúster conlleva un gasto económico (aunque no muy alto).

Despliegue sobre kubernetes

Desplegando sobre kubernetes he tenido otras problemáticas. Son las siguientes:

Falta de documentación/ejemplos: Al ser una extensión de Crossplane, los problemas relacionados con la falta de comunidad también se aplican al proveedor de kubernetes.
Pocas explicaciones: Existe un repositorio oficial con ejemplos, pero para que estos funcionen sobre un clúster en AWS hay que realizar pasos extra que no explican.
Caducidad: Las credenciales que se utilizan para crear el secret de kubernetes que permite la conexión, caducan a los 30 minutos.

Conclusión

Con la realización del proyecto hemos podido comprender mejor la infraestructura como código, así como la implementación de ésta por medio de una nueva tecnología que es Crossplane, aplicando este conocimiento a desplegar un clúster de EKS en Amazon Web Services y una aplicación dentro del mismo, haciendo uso de un entorno con múltiples proveedores, aprovechando las funcionalidades que este ofrece. Al ser Crossplane una herramienta tan versátil y potente, hay muchas cosas que se pueden hacer que no se han llegado a tocar en el proyecto.

También, y, a consecuencia del tema del proyecto, hemos aprendido acerca de la metodología GitOps y cómo aplicarla utilizando ArgoCD, que sirve a la perfección para este propósito gracias al funcionamiento de sus aplicaciones basadas en repositorios de GitHub.

Finalmente, se ha profundizado en el funcionamiento de kubernetes, aprendiendo acerca del plano de control y de las diferentes APIs que gestionan los recursos.

En conclusión, Crossplane es una herramienta muy polifacética y útil, siendo su principal virtud, trasladar la infraestructura como código al terreno de kubernetes, haciendo así que sea especialmente atractiva, y, tras un poco de aprendizaje, una herramienta a tener en cuenta de cara a desplegar infraestructura.

Bibliografía

Crossplane on Amazon EKS (canal Containers from the Couch): https://www.youtube.com/live/aWRWKnniqeM?feature=share
Documentación de Crossplane: https://docs.crossplane.io/v1.12/
Proveedores de Crossplane: https://docs.crossplane.io/latest/concepts/providers/
Documentación de la api de los diferentes proveedores:
- AWS: https://doc.crds.dev/github.com/crossplane/provider-aws
- Helm: https://doc.crds.dev/github.com/crossplane-contrib/provider-helm
- K8s: https://doc.crds.dev/github.com/crossplane-contrib/provider-kubernetes
AWS Quickstart: https://docs.crossplane.io/v1.12/getting-started/provider-aws/
Production ready EKS Cluster with Crossplane: https://www.kloia.com/blog/production-ready-eks-cluster-with-crossplane
GitOps model for provisioning and bootstrapping Amazon EKS clusters using Crossplane and Flux: https://aws.amazon.com/es/blogs/containers/gitops-model-for-provisioning-and-bootstrapping-amazon-eks-clusters-using-crossplane-and-flux/
Ejemplos del proveedor de kubernetes: https://github.com/crossplane-contrib/provider-kubernetes

Sistema de copias de seguridad

Tue, 07 Mar 2023 00:00:00 GMT

Enunciado

Implementar un sistema de copias de seguridad para las instancias del cloud, teniendo en cuenta las siguientes características:

Selecciona una aplicación para realizar el proceso: bacula, amanda, shell script con tar, rsync, dar, afio, etc.
Utiliza una de las instancias como servidor de copias de seguridad, añadiéndole un volumen y almacenando localmente las copias de seguridad que consideres adecuadas en él.
El proceso debe realizarse de forma completamente automática
Selecciona qué información es necesaria guardar (listado de paquetes, ficheros de configuración, documentos, datos, etc.)
Realiza semanalmente una copia completa
Realiza diariamente una copia incremental o diferencial (decidir cual es más adecuada)
Implementa una planificación del almacenamiento de copias de seguridad para una ejecución prevista de varios años, detallando qué copias completas se almacenarán de forma permanente y cuales se irán borrando
Selecciona un directorio de datos "críticos" que deberá almacenarse cifrado en la copia de seguridad, bien encargándote de hacer la copia manualmente o incluyendo la contraseña de cifrado en el sistema
Incluye en la copia los datos de las nuevas aplicaciones que se vayan instalando durante el resto del curso
Utiliza una ubicación secundaria para almacenar las copias de seguridad. Solicita acceso o la instalación de las aplicaciones que sean precisas.

La corrección consistirá tanto en la restauración puntual de un fichero en cualquier fecha como la restauración completa de una de las instancias la última semana de curso.

El escenario es el siguiente_

Máquina	IPs	tipo
alfa	172.22.200.218, 172.16.0.1, 192.168.0.1	Debian
bravo	172.16.0.200	Rocky Linux
charlie	192.168.0.2	Contenedor ubuntu
delta	192.168.0.3	Contenedor ubuntu

Preparaciones previas

Y he decidido hacer las copias de seguridad desde alfa, ya que tiene conexión directa con las otras instancias. Para ello, voy a utilizar bacula, junto con su interfaz web baculum, tras ver las características de las distintas herramientas.

Antes de la instalación, compruebo que en alfa en total se han usado en disco 4.5 GB y en bravo 1.9 GB. Como charlie y delta son contenedores, el espacio ya se ha contado en alfa. Teniendo en cuenta el espacio usado, con un disco de 30 GB debería ser suficiente para guardar las copias de seguridad, tanto incrementales como completas.

Al disco le he instalado XFS por sus características de tolerancia a fallos, y lo he añadido a /etc/fstab para que se monte automáticamente al iniciar el sistema.

Creo la carpeta /bacula en la que va a estar montado permanentemente el disco, y le cambio el propietario y los permisos:

mkdir -p /bacula
chown -R bacula:bacula /bacula/
chmod 755 -R /bacula

Ahora, añado la siguiente línea al fichero /etc/fstab:

UUID=5f086e6b-6937-460b-93ab-1a65a9e12544 /bacula xfs defaults 0 1

Instalación de bacula

Primero instalo los paquetes de bacula

apt install bacula bacula-common-mysql bacula-director-mysql

Durante la instalacion de bacula-director-mysql pregunta lo siguiente, le doy a yes e introduzco la contraseña de la base de datos.

Ahora instalo baculum, primero añado los repositorios:

wget -qO - http://www.bacula.org/downloads/baculum/baculum.pub | apt-key add -
echo "deb http://www.bacula.org/downloads/baculum/stable/debian buster main
deb-src http://www.bacula.org/downloads/baculum/stable/debian buster main" > /etc/apt/sources.list.d/baculum.list

Primero instalo los paquetes de la api

apt update
apt-get install apache2 baculum-common baculum-api baculum-api-apache2
a2enmod rewrite
a2ensite baculum-api
systemctl restart apache2

Y ahora los paquetes de la interfaz web

apt-get install baculum-common baculum-web baculum-web-apache2
a2enmod rewrite
a2ensite baculum-web
systemctl restart apache2

Configuración de la api

Primero accedo a http://172.22.200.218:9096/ , introduzco el usuario y contraseña por defecto (admin/admin) y configuro la api:

Ahora, para permitir el acceso a la consola de bacula, edito el fichero nano /etc/sudoers.d/baculum-api y añado las siguiente líneas:

Defaults:www-data !requiretty
www-data ALL = (root) NOPASSWD: /usr/sbin/bconsole
www-data ALL = (root) NOPASSWD: /usr/sbin/bdirjson
www-data ALL = (root) NOPASSWD: /usr/sbin/bsdjson
www-data ALL = (root) NOPASSWD: /usr/sbin/bfdjson
www-data ALL = (root) NOPASSWD: /usr/sbin/bbconsjson
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl start bacula-dir
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl stop bacula-dir
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl restart bacula-dir
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl start bacula-sd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl stop bacula-sd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl restart bacula-sd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl start bacula-fd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl stop bacula-fd
www-data ALL = (root) NOPASSWD: /usr/bin/systemctl restart bacula-fd

Ahora creamos un usuario y una contraseña para la api

Configuramos, ahora si, baculum en http://172.22.200.218:9095/

y utilizamos las credenciales de la api en la configuración:

Configuración del servidor en alfa

Selecciona qué información es necesaria guardar

En todas las instancias voy a guardar el contenido de /home, /etc, /var, /opt, /usr/share (menos los archivos temporales de var). Además de esto, en diferentes instancias voy a guardar lo siguiente:

Instancia	Servicios	Localización
alfa	bacula	/var/log
bravo	httpd	/var/www, /etc/httpd
charlie	dns	/var/chache/bind, /etc/bind
delta	correo	/etc/postfix

Cada día voy a hacer copias incrementales, cada semana se realizará una completa, al igual que cada mes.

Teniendo en cuenta esto, voy a configurar alfa utilizando los ficheros de configuración (por facilidad respecto a la interfaz web). Primero edito el fichero /etc/bacula/bacula-dir.conf, cambiando su contenido por el siguiente (es un fichero en mi github debido a la longitud del mismo):

bacula-dir.conf

compruebo que no hay errores en el fichero de configuración:

bacula-dir -t -c /etc/bacula/bacula-dir.conf

Y tras eso, modifico el fichero /etc/bacula/bacula-sd.conf,que contiene la configuración referente a los dispositivos de almacenamiento, cambiando su contenido por el siguiente (es un fichero en mi github debido a la longitud del mismo):

bacula-sd.conf

Al igual que antes, compruebo que no hay errores en el fichero de configuración:

bacula-sd -t -c /etc/bacula/bacula-sd.conf

y reinicio los servicios:

systemctl restart bacula-sd.service
systemctl enable bacula-sd.service
systemctl restart bacula-director.service
systemctl enable bacula-director.service

Preparación de los clientes

Alfa

Alfa va a ser a la vez cliente y servidor, por lo que voy a instalar el cliente también en alfa:

apt install bacula-client
systemctl enable bacula-fd.service

Ahora modifico el fichero /etc/bacula/bacula-fd.conf:

Director {
  Name = alfa-dir
  Password = "bacula"
}

Director {
  Name = alfa-mon
  Password = "bacula"
  Monitor = yes
}

FileDaemon {                          # this is me
  Name = alfa-fd
  FDport = 9102                  # where we listen for the director
  WorkingDirectory = /var/lib/bacula
  Pid Directory = /run/bacula
  Maximum Concurrent Jobs = 20
  Plugin Directory = /usr/lib/bacula
  FDAddress = 10.0.0.247
}

# Send all messages except skipped files back to Director
Messages {
  Name = Standard
  director = alfa-dir = all, !skipped, !restored
}

Y reinicio el servicio:

systemctl restart bacula-fd.service

Bravo

Instalo el cliente

sudo dnf install bacula-client

Y edito el fichero /etc/bacula/bacula-fd.conf y añado las siguientes líneas:

Director {
  Name = alfa-dir
  Password = "bacula"
}

Director {
  Name = alfa-mon
  Password = "bacula"
  Monitor = yes
}

FileDaemon {
  Name = bravo-fd
  FDport = 9102
  WorkingDirectory = /var/lib/bacula
  Pid Directory = /run/bacula
  Maximum Concurrent Jobs = 20
  Plugin Directory = /usr/lib/bacula
  FDAddress = 172.16.0.200
}

Messages {
  Name = Standard
  director = alfa-dir = all, !skipped, !restored
}

firewall-cmd --permanent --add-port=22/tcp
firewall-cmd --permanent --add-port=80/tcp

firewall-cmd --permanent --add-port=9101/tcp
firewall-cmd --permanent --add-port=9102/tcp
firewall-cmd --permanent --add-port=9103/tcp
firewall-cmd --reload

Charlie y delta

La configuración en charlie y delta es similar, por eso la pongo junta:

sudo apt install bacula-client

Y edito el fichero /etc/bacula/bacula-fd.conf:

Director {
  Name = alfa-dir
  Password = "bacula"
}

Director {
  Name = alfa-mon
  Password = "bacula"
  Monitor = yes
}

FileDaemon {                          # this is me
  Name = delta-fd
  FDport = 9102                  # where we listen for the director
  WorkingDirectory = /var/lib/bacula
  Pid Directory = /run/bacula
  Maximum Concurrent Jobs = 20
  Plugin Directory = /usr/lib/bacula
  FDAddress = 192.168.0.3
}

# Send all messages except skipped files back to Director
Messages {
  Name = Standard
  director = alfa-dir = all, !skipped, !restored
}

Y reinicio el servicio:

systemctl restart bacula-fd.service

Ahora, con todos los cliente configurados, reinicio los servicios de bacula en alfa:

systemctl restart bacula-fd.service
systemctl restart bacula-sd.service
systemctl restart bacula-director.service

y hago una prueba de conexión usando la consola de bácula y la interfaz web:

bconsole

Nodos de almacenamiento

Ahora voy a crear los nodos de almacenamiento con bconsole

bconsole

También se puede hacer desde la interfaz web:

Realizo la misma configuración para vol-semanal y vol-mensual.

Podemos ver que se han creado los volúmenes:

Restauración

Voy a realizar la restauración por medio de la interfaz web. Para ello utilizo la opción de Perform restore y sigo los siguientes pasos:

Selecciono qué quiero copiar y donde:

y que reemplace los ficheros más antiguos:

Cuando acabe puedo ver que se ha ejecutado con éxito:

Cortafuegos III: perimetral sobre escenario

Thu, 02 Mar 2023 00:00:00 GMT

El escenario es el siguiente

Y las interfaces de alfa son las siguientes:

ens3: Salida a internet
ens8: DMZ
br-intra: LAN

Enunciado

Sobre el escenario creado en el módulo de servicios con las máquinas Alfa (Router), Bravo (DMZ), Charlie y Delta (LAN) y empleando iptables o nftables, configura un cortafuegos perimetral en la máquina Alfa de forma que el escenario siga funcionando completamente teniendo en cuenta los siguientes puntos:

Política por defecto DROP para las cadenas INPUT, FORWARD y OUTPUT.

Antes de añadir la política por defecto voy a añadir reglas para permitir el acceso por ssh

iptables -A INPUT -s 172.22.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.22.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Estas reglas sirve para acceder desde la misma red, además añado las siguientes para acceder a través de la VPN

iptables -A INPUT -s 172.29.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.29.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Y permito el acceso al resto de máquinas

iptables -A OUTPUT -d 192.168.0.0/24 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 192.168.0.0/24 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

iptables -A OUTPUT -d 172.16.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 172.16.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

(Este paso lo ejecuto después de crear las reglas ssh)

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP

El cortafuego debe cumplir al menos estas reglas:

La máquina Alfa tiene un servidor ssh escuchando por el puerto 22, pero al acceder desde el exterior habrá que conectar al puerto 2222.

Desde Delta y Bravo se debe permitir la conexión ssh por el puerto 22 a la máquina Alfa

de alfa a charlie/delta

sudo iptables -A OUTPUT -o br-intra -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
sudo iptables -A INPUT -i br-intra -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Prueba antes y después de crear la regla

de alfa a bravo

sudo iptables -A OUTPUT -o ens8 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
sudo iptables -A INPUT -i ens8 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

La máquina Alfa debe tener permitido el tráfico para la interfaz loopback

iptables -A INPUT -i lo -p icmp -j ACCEPT
iptables -A OUTPUT -o lo -p icmp -j ACCEPT

Pruebo que funciona, antes y después de aplicar la regla:

A la máquina Alfa se le puede hacer ping desde la DMZ, pero desde la LAN se le debe rechazar la conexión (REJECT) y desde el exterior se rechazará de manera silenciosa.

iptables -A INPUT -s 172.16.0.200/16 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A OUTPUT -d 172.16.0.200/16 -p icmp -m icmp --icmp-type echo-reply -j ACCEPT

Ahora el reject a la LAN

iptables -A INPUT -s 192.168.1.0/24 -p icmp -m icmp --icmp-type echo-request -j REJECT
iptables -A OUTPUT -d 192.168.1.0/24 -p icmp -m icmp --icmp-type echo-reply -j REJECT

ping desde bravo:

ping desde charlie:

La máquina Alfa puede hacer ping a la LAN, la DMZ y al exterior.

iptables -A OUTPUT -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A INPUT -p icmp -m icmp --icmp-type echo-reply -j ACCEPT

A la LAN:

A la DMZ:

Al exterior:

Desde la máquina Bravo se puede hacer ping y conexión ssh a las máquinas de la LAN.

iptables -A FORWARD -s 172.16.0.200/32 -d 192.168.0.0/24 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A FORWARD -d 172.16.0.200/32 -s 192.168.0.0/24 -p icmp -m icmp --icmp-type echo-reply -j ACCEPT

iptables -A FORWARD -s 172.16.0.200/32 -d 192.168.0.0/24 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -d 172.16.0.200/32 -s 192.168.0.0/24 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Prueba de ping desde bravo a charlie:

Prueba de ssh desde bravo a charlie:

Desde cualquier máquina de la LAN se puede conectar por ssh a la máquina Bravo.

iptables -A FORWARD -s 192.168.0.0/24 -d 172.16.0.200/32 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -s 172.16.0.200/32 -d 192.168.0.0/24 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Pruebo a acceder desde charlie:

Configura la máquina Alfa para que las máquinas de LAN y DMZ puedan acceder al exterior

DMZ a exterior:

iptables -t nat -A POSTROUTING -s 172.16.0.0/16 -o ens3 -j MASQUERADE
iptables -A FORWARD -i ens8 -o ens3 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A FORWARD -i ens3 -o ens8 -p icmp -m icmp --icmp-type echo-reply -j ACCEPT

LAN a exterior:

iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o ens3 -j MASQUERADE
iptables -A FORWARD -i br-intra -o ens3 -p icmp -m icmp --icmp-type echo-request -j ACCEPT
iptables -A FORWARD -i ens3 -o br-intra -p icmp -m icmp --icmp-type echo-reply -j ACCEPT

Prueba de ping desde bravo a google:

Prueba de ping desde charlie a google:

Las máquinas de la LAN pueden hacer ping al exterior y navegar

El ping lo he configurado en el punto anterior. Ahora la navegación:

iptables -A FORWARD -i br-intra -o ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o br-intra -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

iptables -A FORWARD -i br-intra -o ens3 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o br-intra -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT

Prueba de navegación desde charlie (no tengo el comando curl, asi que uso nc):

La máquina Bravo puede navegar

iptables -A FORWARD -i ens8 -o ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o ens8 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

iptables -A FORWARD -i ens8 -o ens3 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens3 -o ens8 -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT

Prueba de navegación desde bravo:

Configura la máquina Alfa para que los servicios web y ftp sean accesibles desde el exterior

iptables -t nat -A PREROUTING -p tcp -i ens3 --dport 80 -j DNAT --to 172.16.0.200
iptables -A FORWARD -i ens3 -o ens8 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o ens3 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

iptables -t nat -A PREROUTING -p tcp -i ens3 --dport 21 -j DNAT --to 172.16.0.200
iptables -A FORWARD -i ens3 -o ens8 -p tcp --dport 21 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o ens3 -p tcp --sport 21 -m state --state ESTABLISHED -j ACCEPT

Prueba de navegación desde el exterior (La página es de un taller de Django):

El servidor web y el servidor ftp deben ser accesibles desde la LAN y desde el exterior

iptables -A FORWARD -i br-intra -o ens8 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o br-intra -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

iptables -A FORWARD -i br-intra -o ens8 -p tcp --dport 21 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o br-intra -p tcp --sport 21 -m state --state ESTABLISHED -j ACCEPT

Prueba de navegación desde charlie, sale un error porque estoy usando el comando nc, pero aun asi se ve que responde rocky con wsgi, que es lo que hay desplegado en bravo:

El servidor de correos sólo debe ser accesible desde la LAN

iptables -A FORWARD -i br-intra -o ens8 -p tcp --dport 25 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i ens8 -o br-intra -p tcp --sport 25 -m state --state ESTABLISHED -j ACCEPT

En la máquina Charlie instala un servidor mysql si no lo tiene aún. A este servidor se puede acceder desde la DMZ, pero no desde el exterior.

Evita ataques DoS por ICMP Flood, limitando el número de peticiones por segundo desde una misma IP.

El ping está bloqueado desde el exterior y desde la LAN, por lo que voy a evitar los ataques desde la DMZ, limitando a 1 peticion por segundo(primero hay que borrar la regla anterior):

iptables -A INPUT -i ens8 -p icmp -m state --state NEW --icmp-type echo-request -m limit --limit 1/s --limit-burst 1 -j ACCEPT

En la captura se ve como el 100% de los paquetes han sido rechazados

Evita ataques DoS por SYN Flood.

iptables -t raw -D PREROUTING -p tcp -m tcp --syn -j CT --notrack
iptables -D INPUT -p tcp -m tcp -m conntrack --ctstate INVALID,UNTRACKED -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460
iptables -D INPUT -m conntrack --ctstate INVALID -j DROP

Evita que realicen escaneos de puertos a Alfa.

iptables -N antiscan
iptables -A antiscan -j DROP

Debemos implementar que el cortafuegos funcione después de un reinicio de la máquina.

Para hacer la instalación persistente, he utilizado el paquete iptables-persistent

apt install iptables-persistent

Para que funcione, tras crear todas las reglas, ejecuto el siguiente comando:

sudo iptables-save > /etc/iptables/rules.v4

Tras ejecutar eso, las reglas son persistentes. El fichero tiene el siguiente contenido:

Poblar un directorio LDAP desde un fichero CSV

Wed, 22 Feb 2023 00:00:00 GMT

En alfa creo el siguiente fichero CSV:

Belen,Nazareth,belennazareth@gmail.com,nazareth,ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC73j7AidXdLgiu5wJw7YgJuvOHyb6U8c04MuQyehYnMknMR8mTnWZr20npVHJ8VHYHDy8RlgbkMMBFgeVCgXJ+Im3A6Efp6HC4yj2SM+73hr1EKCLdRPzCzdtDSUtkqU9k+x2RdF3T6qD6H4Cg/nT8Sg3Qenqds4XORfDWOvntxFja2D0OhZv1MLPUD9pEj+a8D4erfiPx/gKW/Rtu89une+uiwVgK60B5CxnC8XXnXmPO3NhrgyQhVgzQZ658cUbLooxQURVlo1gnOmcqX5h+svUKN1SDbzTyy7HKSk7bbLHEhk7qDh7jSzcf80GLU0li8vXc2to8NpC00EOQ9POPivESz23gMNY8ooDtNU3Ll/xYvhtvXrJNTbuBiuVLzuopMvrQi6LVsQEWmPJzBiJ2qt8JW1KRLcnWRL4AezbxAPXuRYVnYBS3it6L0J4AZjZg63BkIIrfU7GYzrKb+z5mqUgDJhIZ4d5av+OAxPSSzNeVnyWEnWrI0k9kf9qmqhU= nazare@ThousandSunny 
Antonio,Marchan,antoniomarchan@gmail.com,anthony,ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC9kx67eVF+Eh5epqZvQfjOLamYck9lVB9w1e/JO9Nzx7Utxm0ikD4ZCuhANc42RRkbH/2xICo138IpxJtfnbf4ObmaxVpo65lweLw5e8w132v6IXHkCAU5jTdyJS08Gi5I/nEqq/ywEMWJ939zEu0Dfdi/1IDlqBjGPpeomCJCDOkZWHfFyuiHrpgbWniwjRBcQiXjlp7w76/k0K+1Xw5JQz2F/YuTHzEGXqVo7x2T32IprzONXprVd9cn5qItFES5DMHOv62t++3zAOZbLNTs+cFuZmfTkT4YQUoHPkqXCzQmM6hnSAihOQjNKZWy+zSOiTkL22tdd9q4jhUZu4VutNeEFKt4VDlLH1uEV0FCJjb5Fw2gzb62D9sjdsjNa8EZD2IcrjKrIJv83Ca7AyeED5egoFSAMfW1iFIse8pG4olOOv4FyeWtSgjgv9A+URiwkRqFd371lw6Xj0gdEokqO9sBYlcy3gfwT4BZCSlM3AMOjFCMP5kU1Z8uTowg9NM= antonio@debian

Creo el siguiente fichero ldif openssh-lpk.ldif:

dn: cn=openssh-lpk,cn=schema,cn=config
objectClass: olcSchemaConfig
cn: openssh-lpk
olcAttributeTypes: ( 1.3.6.1.4.1.24552.500.1.1.1.13 NAME 'sshPublicKey'
  DESC 'MANDATORY: OpenSSH Public key'
  EQUALITY octetStringMatch
  SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )
olcObjectClasses: ( 1.3.6.1.4.1.24552.500.1.1.2.0 NAME 'ldapPublicKey' SUP top AUXILIARY
  DESC 'MANDATORY: OpenSSH LPK objectclass'
  MAY ( sshPublicKey $ uid )
  )

Ahora, creo un entorno virtual:

apt install python3-venv -y
python3 -m venv entorno_ldap
source entorno_ldap/bin/activate
pip install ldap3

Y el siguiente programa ldap_csv.py:

#!/usr/bin/env python

import ldap3
from ldap3 import Connection, ALL
from getpass import getpass
from sys import exit

### VARIABLES

# Shell que se le asigna a los usuarios
shell = '/bin/bash'

# Ruta absoluta del directorio que contiene los directorios personales de los usuarios. Terminado en "/"
home_dir = '/home/ldap/'

# El valor inicial para los UID que se asignan al insertar usuarios. 
uid_number = 500

# El GID que se le asigna a los usuarios. Si no se manda al anadir el usuario da error.
gid = 500

### VARIABLES

# Leemos el fichero .csv de los usuarios y guardamos cada linea en una lista.
with open('usuarios.csv', 'r') as usuarios:
  usuarios = usuarios.readlines()


### Parametros para la conexion
ldap_ip = 'ldap://alfa.roberto.gonzalonazareno.org:389'
dominio_base = 'dc=roberto,dc=gonzalonazareno,dc=org'
user_admin = 'admin' 
contrasena = getpass('Contrasena: ')

# Intenta realizar la conexion.
conn = Connection(ldap_ip, 'cn={},{}'.format(user_admin, dominio_base),contrasena)

# conn.bind() devuelve "True" si se ha establecido la conexion y "False" en caso contrario.

# Si no se establece la conexion imprime por pantalla un error de conexion.
if not conn.bind():
  print('No se ha podido conectar con ldap') 
  if conn.result['description'] == 'invalidCredentials':
    print('Credenciales no validas.')
  # Termina el script.
  exit(0)

# Recorre la lista de usuarios
for user in usuarios:
  # Separa los valores del usuario usando como delimitador ",", y asigna cada valor a la variable correspondiente.
  user = user.split(',')
  cn = user[0]
  sn = user[1]
  mail = user[2]
  uid = user[3]
  ssh = user[4]

  #Anade el usuario.
  conn.add(
    'uid={},ou=Personas,{}'.format(uid, dominio_base),
    object_class = 
      [
      'inetOrgPerson',
      'posixAccount', 
      'ldapPublicKey'
      ],
    attributes =
      {
      'cn': cn,
      'sn': sn,
      'mail': mail,
      'uid': uid,
      'uidNumber': str(uid_number),
      'gidNumber': str(gid),
      'homeDirectory': '{}{}'.format(home_dir,uid),
      'loginShell': shell,
      'sshPublicKey': str(ssh)
      })

  if conn.result['description'] == 'entryAlreadyExists':
    print('El usuario {} ya existe.'.format(uid))

  # Aumenta el contador para asignar un UID diferente a cada usuario (cada vez que ejecutemos el script debemos asegurarnos de ante mano que no existe dicho uid en el directorio ldap, o se solaparian los datos)
  uid_number += 1

#Cierra la conexion.
conn.unbind()

Los ejecuto

python3 ldap_csv.py

Tras eso, podemos realizar un ldapsearch para comprobar que se han añadido los usuarios correctamente:

ldapsearch -x -D "cn=admin,dc=roberto,dc=gonzalonazareno,dc=org" -b "dc=roberto,dc=gonzalonazareno,dc=org" -W

Editamos el fichero /etc/ldap/ldap.conf

BASE dc=roberto,dc=gonzalonazareno,dc=org
URI ldap://roberto.antonio.gonzalonazareno.org

en el fichero /etc/pam.d/common-session añadimos la siguiente linea al final:

session    required        pam_mkhomedir.so

Ahora creo el siguiente script para encontrar las claves públicas del árbol de LDAP en /opt/buscarclave.sh y le damos permiso de ejecución:

#!/bin/bash

ldapsearch -x -u -LLL -o ldif-wrap=no '(&(objectClass=posixAccount)(uid='"$1"'))' 'sshPublicKey' | sed -n 's/^[ \t]*sshPublicKey::[ \t]*\(.*\)/\1/p' | base64 -d

Y le pongo permisos 755:

chmod 755 /opt/buscarclave.sh

Ahora compruebo que funciona:

ahora edito el fichero /etc/ssh/sshd_config y reinicio el servicio sshd:

AuthorizedKeysCommand /opt/buscarclave.sh
AuthorizedKeysCommandUser nobody

Ahora tras eso, Antonio puede conectarse con su usuario:

Administración de Bases de Datos - Auditoria

Tue, 21 Feb 2023 00:00:00 GMT

Activa desde SQL*Plus la auditoría de los intentos de acceso exitosos al sistema. Comprueba su funcionamiento

Para activar la auditoría y que los datos se almacenen en la base de datos, ejecutamos el siguiente comando:

ALTER SYSTEM SET audit_trail=db scope=spfile;

Para comprobar que se ha activado correctamente, ejecutamos el siguiente comando:

SELECT name, value FROM v$parameter WHERE name like 'audit_trail';

Para activar la auditoría de los intentos de acceso exitosos al sistema, ejecutamos el siguiente comando:

AUDIT CREATE SESSION WHENEVER SUCCESSFUL;

Ahora, tras acceder a la base de datos con el usuario restaurante (de una práctica anterior), haciendo la siguiente consulta, puedo ver que se ha almacenado la información del acceso:

SELECT OS_USERNAME, USERNAME, EXTENDED_TIMESTAMP, ACTION_NAME FROM DBA_AUDIT_SESSION;

Realiza un procedimiento en PL/SQL que te muestre los accesos fallidos junto con el motivo de los mismos, transformando el código de error almacenado en un mensaje de texto comprensible. Contempla todos los motivos posibles para que un acceso sea fallido

Primero, para vaciar la tabla de auditoría, ejecuto el siguiente comando:

TRUNCATE table sys.AUD$;

Ahora creo una sesión de auditoría para los accesos fallidos:

AUDIT CREATE SESSION WHENEVER NOT SUCCESSFUL;

He obtenido el significado de los códigos de error de la siguiente página: http://johanlouwers.blogspot.com/2013/01/oracle-database-login-audit.html

Código	Significado
00911	El nombre de usuario o la contraseña contiene un carácter no válido
00988	Falta la contraseña o no es válida
01004	Inicio de sesión denegado
01005	Contraseña nula
01017	Contraseña / usuario no válidos
01031	Sin privilegios
01045	El usuario no tiene el privilegio CREATE SESSION
01918	No existe el user ID
01920	No existe el rol
09911	Contraseña incorrecta
28000	La cuenta está bloqueada
28001	La contraseña ha caducado
28002	La contraseña caducará pronto, se debe cambiar ahora
28003	La contraseña no es lo suficientemente compleja
28007	La contraseña no se puede reutilizar
28008	Contraseña antigua no válida
28009	La conexión a sys se debe realizar desde sysdba o sysoper
28011	La cuenta va a caducar pronto, se debe cambiar la contraseña
28221	La contraseña original no ha sido suministrada

Ahora, creo el procedimiento en PL/SQL:

CREATE OR REPLACE PROCEDURE accesosFallidos
IS
    CURSOR c_accesos IS
        SELECT USERNAME, EXTENDED_TIMESTAMP, ACTION_NAME, RETURNCODE
        FROM DBA_AUDIT_SESSION
        WHERE RETURNCODE <> 0;
begin
    for i in c_accesos loop
        dbms_output.put_line('HORA: ' || i.EXTENDED_TIMESTAMP);
        dbms_output.put_line(CHR(9)||'-USUARIO: ' || i.USERNAME);
        case i.RETURNCODE
            when 00911 then
                dbms_output.put_line(CHR(9)||'-El nombre de usuario o la contrasena contiene un caracter no valido');
            when 00988 then
                dbms_output.put_line(CHR(9)||'-Falta la contrasena o no es valida');
            when 01004 then
                dbms_output.put_line(CHR(9)||'-Inicio de sesion denegado');
            when 01005 then
                dbms_output.put_line(CHR(9)||'-contrasena nula');
            when 01017 then
                dbms_output.put_line(CHR(9)||'-contrasena / usuario no validos');
            when 01031 then
                dbms_output.put_line(CHR(9)||'-Sin privilegios');
            when 01045 then
                dbms_output.put_line(CHR(9)||'-El usuario no tiene el privilegio CREATE SESSION');
            when 01918 then
                dbms_output.put_line(CHR(9)||'-No existe el user ID');
            when 01920 then
                dbms_output.put_line(CHR(9)||'-No existe el rol');
            when 09911 then
                dbms_output.put_line(CHR(9)||'-contrasena incorrecta');
            when 28000 then
                dbms_output.put_line(CHR(9)||'-La cuenta esta bloqueada');
            when 28001 then
                dbms_output.put_line(CHR(9)||'-La contrasena ha caducado');
            when 28002 then
                dbms_output.put_line(CHR(9)||'-La contrasena caducara pronto, se debe cambiar ahora');
            when 28003 then
                dbms_output.put_line(CHR(9)||'-La contrasena no es lo suficientemente compleja');
            when 28007 then
                dbms_output.put_line(CHR(9)||'-La contrasena no se puede reutilizar');
            when 28008 then
                dbms_output.put_line(CHR(9)||'-contrasena antigua no valida');
            when 28009 then
                dbms_output.put_line(CHR(9)||'-La conexión a sys se debe realizar desde sysdba o sysoper');
            when 28011 then
                dbms_output.put_line(CHR(9)||'-La cuenta va a caducar pronto, se debe cambiar la contrasena');
            when 28221 then
                dbms_output.put_line(CHR(9)||'-La contrasena original no ha sido suministrada');
        end case;
    end loop;
end;
/

Compruebo que funciona correctamente:

Activa la auditoría de las operaciones DML realizadas por SCOTT. Comprueba su funcionamiento

Activo la auditoría de las operaciones DML realizadas por SCOTT:

AUDIT INSERT TABLE, UPDATE TABLE, DELETE TABLE BY SCOTT BY ACCESS;

Ahora inserto un empleado en la tabla emp:

INSERT INTO emp VALUES (9999, 'Roberto', 'Director', 7839, TO_DATE('21/02/2023', 'DD/MM/YYYY'), 5000, 0, 10);

Y se ve reflectado en la tabla de auditoría:

SELECT USERNAME, OBJ_NAME, ACTION_NAME, EXTENDED_TIMESTAMP FROM DBA_AUDIT_OBJECT;

Realiza una auditoría de grano fino para almacenar información sobre la inserción de empleados con sueldo superior a 2000 en la tabla emp de scott

La auditoría de grano fino (FGA) es como una versión extendida de la auditoría estándar. Registra los cambios en datos muy concretos a nivel de columna.

Para realizar la auditoría de grano fino, primero tengo que crear una política de auditoría:

BEGIN
    DBMS_FGA.ADD_POLICY (
    OBJECT_SCHEMA      => 'SCOTT',
    OBJECT_NAME        => 'EMP',
    POLICY_NAME        => 'SALARIO_MAYOR_2000',
    AUDIT_CONDITION    => 'SAL < 2000',
    STATEMENT_TYPES    => 'INSERT'
    );
END;
/

Ahora inserto varios empleados:

INSERT INTO emp VALUES (2222, 'Bill Gates', 'Director', 7839, TO_DATE('21/02/2023', 'DD/MM/YYYY'), 1000, 0, 10);
INSERT INTO emp VALUES (3333, 'Steve Jobs', 'Director', 7839, TO_DATE('21/02/2023', 'DD/MM/YYYY'), 5000, 0, 10);

Y compruebo que aparece en la tabla de auditoría:

SELECT DB_USER, OBJECT_NAME, SQL_TEXT, EXTENDED_TIMESTAMP FROM DBA_FGA_AUDIT_TRAIL WHERE POLICY_NAME='SALARIO_MAYOR_2000';

Explica la diferencia entre auditar una operación by access o by session ilustrándolo con ejemplos

Las operaciones by access se auditan por cada acceso a la base de datos, mientras que las operaciones by session se auditan por cada sesión de usuario. Por ejemplo, si un usuario realiza 10 accesos a la base de datos, se auditarán 10 operaciones by access, mientras que si realiza 10 accesos en una misma sesión, se auditarán 1 operación by session.

La sintaxis es la siguiente:

AUDIT [operación] [tabla] BY [usuario] BY {ACCESS | SESSION};

Documenta las diferencias entre los valores db y db, extended del parámetro audit_trail de ORACLE. Demuéstralas poniendo un ejemplo de la información sobre una operación concreta recopilada con cada uno de ellos

Ambos parámetros indican que la auditoría está activada. La diferencia es que el parámetro db guarda la información en la tabla de auditoría, mientras que el parámetro db, extended guarda la información en la tabla de auditoría y en el archivo de alerta.

Para cambiar el parámetro, utilizo el siguiente comando:

ALTER SYSTEM SET audit_trail = db, extended SCOPE = SPFILE;

Reinicio la base de datos y compruebo que el parámetro se ha cambiado correctamente, con la consulta del ejercicio 1:

Averigua si en Postgres se pueden realizar los cuatro primeros apartados. Si es así, documenta el proceso adecuadamente

Ejercicio 1

En postgres no se puede realizar el ejercicio 1, ya que se registran los inicios de sesión fallidos en el archivo de log, pero no los exitosos.

Ejercicio 2

No se puede realizar un procedimiento ya que los accesos fallidos no está registrado en la base de datos, sino en el archivo de log, sin embargo, en el propio archivo de log, se encuentran explicados con palabras y en español, el objetivo final del procedimiento:

Ejercicio 3

Para realizar la auditoría voy a usar Trigger 91plus, una herramienta creada por la comunidad que permite auditar las operaciones DML en postgres.

Para instalarla, primero tengo que descargar de github el siguiente fichero

wget https://raw.githubusercontent.com/2ndQuadrant/audit-trigger/master/audit.sql

Y luego lo instalo:

\i audit.sql

No puede realizar auditorías de todo lo que realiza un usuario, sino de tablas. Por lo que voy a especificar las tablas del usuario scott que quiero auditar:

SELECT audit.audit_table('scott.emp');
SELECT audit.audit_table('scott.dept');

Averigua si en MySQL se pueden realizar los apartados 1, 3 y 4. Si es así, documenta el proceso adecuadamente

Ejercicio 1

Para obtener los datos de los inicios de sesión, edito el fichero /etc/mysql/mariadb.conf.d/50-server.cnf:

general_log_file       = /var/log/mysql/mysql.log
general_log            = 1
log_error = /var/log/mysql/error.log

Cambio el propietario del directorio de los logs y reinicio el servicio:

chown -R mysql:mysql /var/log/mysql
systemctl restart mariadb.service

Ahora, tras varios inicios de sesión, compruebo el fichero de logs /var/log/mysql/mysql.log:

Ejercicio 3

Para realizar la auditoría voy a instalar el plugin server_audit:

INSTALL SONAME 'server_audit';

Ahora edito el fichero /etc/mysql/mariadb.conf.d/50-server.cnf y reinicio mariadb:

[server]
server_audit_events=CONNECT,QUERY,TABLE
server_audit_logging=ON
server_audit_incl_users=scott

Tras insertar un nuevo empleado, compruebo el fichero de log /var/lib/mysql/server_audit.log:

Averigua las posibilidades que ofrece MongoDB para auditar los cambios que va sufriendo un documento. Demuestra su funcionamiento

Para realizar las auditorías, es necesario instalar la versión Enterprise. La documentación de instalación oficial se encuentra en el siguiente enlace https://www.mongodb.com/docs/manual/tutorial/install-mongodb-enterprise-on-debian/. Una vez instalado podemos hacer lo siguiente:

Habilitar las auditorías en el syslog desde la consola:

mongod --dbpath /var/lib/mongodb/ --auditDestination syslog

Habilitar las auditorías en un fichero JSON desde la consola:

mongod --dbpath /var/lib/mongodb/ --auditDestination file --auditFormat JSON --auditPath /var/lib/mongodb/auditLog.json

Habilitar las auditorías en un fichero BSON desde la consola:

mongod --dbpath /var/lib/mongodb/ --auditDestination file --auditFormat BSON --auditPath /var/lib/mongodb/auditLog.bson

Habilitar las auditorías en la consola desde la consola:

mongod --dbpath /var/lib/mongodb/ --auditDestination console

He utilizado la salida por consola y preferencia de formato ya que se trata también de un json.

mongod --dbpath /var/lib/mongodb/ --auditDestination console | jq

##. Averigua si en MongoDB se pueden auditar los accesos a una colección concreta. Demuestra su funcionamiento

Cortafuegos II: Perimetral con nftables

Fri, 17 Feb 2023 00:00:00 GMT

Enunciado

Realiza con nftables el ejercicio de la página https://fp.josedomingo.org/seguridadgs/u03/perimetral_iptables.html documentando las pruebas de funcionamiento realizadas.

Debes añadir después las reglas necesarias para que se permitan las siguientes operaciones:

Preparación

El escenario es el siguiente

Instalo nftables en el cortafuegos

sudo apt update
sudo apt install nftables

Creo las tablas de filter y nat

sudo nft add table inet filter
sudo nft add table inet nat

creo las cadenas de filter

sudo nft add chain inet filter input { type filter hook input priority 0 \; counter \; policy accept \; }
sudo nft add chain inet filter output { type filter hook output priority 0 \; counter \; policy accept \; }
sudo nft add chain inet filter forward { type filter hook forward priority 0 \; counter \; policy accept \; }

creo las cadenas de nat

sudo nft add chain inet nat prerouting { type nat hook prerouting priority 0 \; }
sudo nft add chain inet nat postrouting { type nat hook postrouting priority 100 \; }

SSH al cortafuegos

Ahora acepto el tráfico ssh entrante al router-fw

sudo nft add rule inet filter input ip saddr 172.22.0.0/16 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter output ip daddr 172.22.0.0/16 tcp sport 22 ct state established counter accept

y entrante desde la VPN

sudo nft add rule inet filter input ip saddr 172.29.0.0/16 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter output ip daddr 172.29.0.0/16 tcp sport 22 ct state established counter accept

Política por defecto

Y pongo la política por defecto a drop:

sudo nft chain inet filter input { policy drop \; }
sudo nft chain inet filter output { policy drop \; }

Ahora compruebo que puedo hacer ssh

Activar el bit de forward

En el cortafuegos, activo el bit de forwarding

SNAT

sudo nft add rule inet nat postrouting oifname "ens3" ip saddr 192.168.100.0/24 counter masquerade

SSH desde el cortafuego a la LAN

sudo nft add rule inet filter output oifname "ens4" ip daddr 192.168.100.0/24 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens4" ip saddr 192.168.100.0/24 tcp sport 22 ct state established counter accept

Tráfico para la interfaz loopback

sudo nft add rule inet filter output oifname "lo" counter accept
sudo nft add rule inet filter input iifname "lo" counter accept

Peticiones y respuestas protocolo ICMP

Desde el cortafuegos a internet

sudo nft add rule inet filter input iifname "ens3" icmp type echo-request counter accept
sudo nft add rule inet filter output oifname "ens3" icmp type echo-reply counter accept

Ahora desde mi portátil hago un ping al cortafuegos:

Reglas forward

ping desde la LAN

Desde el cortafuegos a la LAN

sudo nft add rule inet filter input iifname "ens4" icmp type echo-reply counter accept
sudo nft add rule inet filter output oifname "ens4" icmp type echo-request counter accept

Consultas y respuestas DNS desde la LAN

sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 udp dport 53 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 udp sport 53 ct state established counter accept

Permitimos la navegación web desde la LAN

sudo nft add rule inet filter output oifname "ens3" ip protocol tcp tcp dport { 80,443 } ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens3" ip protocol tcp tcp sport { 80,443 } ct state established counter accept

Permitimos el acceso a nuestro servidor web de la LAN desde el exterior

sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 tcp dport 80 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 tcp sport 80 ct state established counter accept

sudo nft add rule inet nat prerouting iifname "ens3" tcp dport 80 counter dnat ip to 192.168.100.10

Reglas del enunciado

Permite poder hacer conexiones ssh al exterior desde la máquina cortafuegos

sudo nft add rule inet filter output oifname "ens3" tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens3" tcp sport 22 ct state established counter accept

Ahora pruebo accediendo a otra máquina desde el cortafuegos por ssh

Permite hacer consultas DNS desde la máquina cortafuegos sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1.

Creo la regla

sudo nft add rule inet filter output ip daddr 192.168.202.2 udp dport 53 ct state new,established counter accept
sudo nft add rule inet filter input ip saddr 192.168.202.2 udp sport 53 ct state established counter accept

Compruebo que no puedo hacer un dig @1.1.1.1 y si uno con @192.168.202.2

Permite que la máquina cortafuegos pueda navegar por internet.

sudo nft add rule inet filter output oifname "ens3" ip protocol tcp tcp dport { 80,443 } ct state new,established counter accept
sudo nft add rule inet filter input iifname "ens3" ip protocol tcp tcp sport { 80,443 } ct state established counter accept

Compruebo que puedo navegar por internet

Los equipos de la red local deben poder tener conexión al exterior.

Este paso lo realicé en la preparación en el siguiente apartado: Reglas forward

Permitimos el ssh desde el cortafuego a la LAN

Este paso lo realicé en la preparación en el siguiente apartado: SSH desde el cortafuego a la LAN

Pruebo que funciona (usando mi clave privada)

Permitimos hacer ping desde la LAN a la máquina cortafuegos

sudo nft add rule inet filter input iifname "ens4" icmp type echo-request counter accept
sudo nft add rule inet filter output oifname "ens4" icmp type echo-reply counter accept

Compruebo que funciona

Permite realizar conexiones ssh desde los equipos de la LAN

sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 tcp sport 22 ct state established counter accept

Ahora, tras copiar mi clave privada a la máquina LAN, accedo a alfa por ssh

Instala un servidor de correos en la máquina de la LAN. Permite el acceso desde el exterior y desde el cortafuego al servidor de correos. Para probarlo puedes ejecutar un telnet al puerto 25 tcp

Permite poder hacer conexiones ssh desde exterior a la LAN

sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip daddr 192.168.100.0/24 tcp dport 22 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 tcp sport 22 ct state established counter accept
sudo nft add rule inet nat prerouting iifname "ens3" tcp dport 22 counter dnat ip to 192.168.100.10

Compruebo que al acceder a la IP del firewall entro en la maquina LAN

Modifica la regla anterior, para que al acceder desde el exterior por ssh tengamos que conectar al puerto 2222, aunque el servidor ssh este configurado para acceder por el puerto 22

sudo nft add rule inet nat prerouting iifname "ens3" tcp dport 2222 counter dnat ip to 192.168.100.10:22

Ahora entro usando el puerto 2222

Permite hacer consultas DNS desde la LAN sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1

Como ya tengo una regla para las consultas dns desde la lan,busco los handles que tiene para borrarla

sudo nft -a list ruleset

son el 22 y el 23. Ahora los borro:

sudo nft delete rule inet filter forward handle 22
sudo nft delete rule inet filter forward handle 23

Ahora añado las reglas para la LAN

sudo nft add rule inet filter forward iifname "ens4" oifname "ens3" ip saddr 192.168.100.0/24 ip daddr 192.168.202.2 udp dport 53 ct state new,established counter accept
sudo nft add rule inet filter forward iifname "ens3" oifname "ens4" ip saddr 192.168.202.2 ip daddr 192.168.100.0/24 udp sport 53 ct state established counter accept

Permite que los equipos de la LAN puedan navegar por internet.

Este paso lo realicé en la preparación en el siguiente apartado: Permite que los equipos de la LAN puedan navegar por internet.

Compruebo que funciona

Cortafuegos I: De nodo con iptables

Wed, 15 Feb 2023 00:00:00 GMT

Enunciado: https://fp.josedomingo.org/seguridadgs/u03/ejercicio1.html

Preparación

Limpiamos las reglas previas

iptables -F
iptables -t nat -F
iptables -Z
iptables -t nat -Z

Acceso por SSH

Antes de añadir la política por defecto voy a añadir reglas para permitir el acceso por ssh

iptables -A INPUT -s 172.22.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.22.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Estas reglas sirve para acceder desde la misma red, además añado las siguientes para acceder a través de la VPN

iptables -A INPUT -s 172.29.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.29.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Ahora añado las políticas por defecto

iptables -P INPUT DROP
iptables -P OUTPUT DROP

Ahora pruebo que se han aplicado, por ejemplo, haciendo un ping:

Permitimos tráfico por la interfaz de loopback

iptables -A INPUT -i lo -p icmp -j ACCEPT
iptables -A OUTPUT -o lo -p icmp -j ACCEPT

Peticiones y respuestas del protocolo ICMP

iptables -A INPUT -i ens3 -p icmp --icmp-type echo-reply -j ACCEPT
iptables -A OUTPUT -o ens3 -p icmp --icmp-type echo-request -j ACCEPT

Pruebo que funciona haciendo un ping

Consultas y respuestas DNS

iptables -A OUTPUT -o ens3 -p udp --dport 53 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p udp --sport 53 -m state --state ESTABLISHED -j ACCEPT

Pruebo que funciona haciendo una consulta DNS

Tráfico HTTP

iptables -A OUTPUT -o ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

Pruebo que funciona haciendo una consulta HTTP

Tráfico HTTPS

iptables -A OUTPUT -o ens3 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT

Pruebo que funciona haciendo una consulta HTTPS

Tráfico HTTP/HTTPs

Los dos puntos anteriores se pueden resumir en una sola regla

iptables -A OUTPUT -o ens3 -p tcp -m multiport --dports 80,443 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -i ens3 -p tcp -m multiport --sports 80,443 -m state --state ESTABLISHED -j ACCEPT

Acceso al servidor web

iptables -A INPUT -i ens3 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o ens3 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT

Pruebo que funciona haciendo una consulta HTTP desde el exterior

Ejercicios

1. Permite poder hacer conexiones ssh al exterior

Para esto uso las reglas de ssh citas anteriormente:

iptables -A INPUT -s 172.22.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.22.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

Estas reglas sirve para acceder desde la misma red, además añado las siguientes para acceder a través de la VPN

iptables -A INPUT -s 172.29.0.0/16 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -d 172.29.0.0/16 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT

2. Deniega el acceso a tu servidor web desde una ip concreta

Como ya he creado en la preparación una regla que permite el acceso al servidor web, para que el bloque funcione tengo que añadir la regla antes, ya que el orden es importante en iptables. Para ello, primero miro la posición de la regla que permite el acceso al servidor web

iptables -L -n -v --line-numbers

La regla que permite el acceso está en la dirección 8; ahora creo la regla con la ip de mi máqunina:

iptables -I INPUT 8 -s 172.29.0.42 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j DROP

Ahora compruebo que no puedo acceder al servidor web desde mi máquina

3. Permite hacer consultas DNS sólo al servidor 192.168.202.2. Comprueba que no puedes hacer un dig @1.1.1.1

Primero borro las reglas de DNS que he creado anteriormente

iptables -D OUTPUT -o ens3 -p udp --dport 53 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -D INPUT -i ens3 -p udp --sport 53 -m state --state ESTABLISHED -j ACCEPT

Y ahora añado las reglas nuevas, permitiendo solo el servidor 192.168.202.2:

iptables -A OUTPUT -d 192.168.202.2 -p udp --dport 53 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -s 192.168.202.2 -p udp --sport 53 -m state --state ESTABLISHED -j ACCEPT

Ahora compruebo que no puedo hacer un dig@1.1.1.1 www.josedomingo.org:

Y si que puedo usando el dns, dig@192.168.202.2 www.josedomingo.org:

4. No permitir el acceso al servidor web de www.josedomingo.org, Tienes que utilizar la ip. ¿Puedes acceder a fp.josedomingo.org?

Al igual que en el ejercicio 2, primero miro la posición de la regla que permite el acceso al servidor web

Está en el lugar 5. Ahora creo la regla con la ip de josedomingo.org:

iptables -I OUTPUT 5 -d 37.187.119.60 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j DROP

Compruebo que se ha creado correctamente:

Ahora compruebo que no puedo acceder al servidor web de josedomingo.org

y si que puedo acceder a portquiz.net:

5. Permite mandar un correo usando nuestro servidor de correo: babuino-smtp. Para probarlo ejecuta un telnet babuino-smtp.gonzalonazareno.org 25

Para hacerlo utilizo la ip de babuino:

iptables -A OUTPUT -d 192.168.203.3 -p tcp --dport 25 -j ACCEPT
iptables -A INPUT -s 192.168.203.3 -p tcp --sport 25 -j ACCEPT

6. Instala un servidor mariadb, y permite los accesos desde la ip de tu cliente. Comprueba que desde otro cliente no se puede acceder

Instalo MariaDB:

apt install mariadb-server

Configuro el acceso remoto, editando el fichero /etc/mysql/mariadb.conf.d/50-server.cnf:

bind-address            = 0.0.0.0

Tras eso, reinicio el servicio y añado la regla para permitir el acceso desde mi cliente:

sudo iptables -A INPUT -s 172.29.0.42 -p tcp --dport 3306 -j ACCEPT
sudo iptables -A OUTPUT -d 172.29.0.42 -p tcp --sport 3306 -j ACCEPT

Ahora, en la siguiente captura, realizo una conexión con la base de datos desde el cliente, tras eso, desconecto la VPN para dejar de tener la IP que está autorizada, y vuelvo a intentar acceder, pero no puedo:

Informática forense

Wed, 08 Feb 2023 00:00:00 GMT

Enunciado

La informática forense es el conjunto de técnicas que nos permite obtener la máxima información posible tras un incidente o delito informático.

En esta práctica, realizarás la fase de toma de evidencias y análisis de las mismas sobre una máquina Linux y otra Windows. Supondremos que pillamos al delincuente in fraganti y las máquinas se encontraban encendidas. Opcionalmente, podéis realizar el análisis de un dispositivo Android.

Sobre cada una de las máquinas debes realizar un volcado de memoria y otro de disco duro, tomando las medidas necesarias para certificar posteriormente la cadena de custodia.

Apartado A. Máquina Windows

Volcado de memoria

Para realizar el volcado de memoria he usado la herramienta FTK Imager, que permite realizar volcados de disco y memoria. Para ello hago lo siguiente. Utilizo las siguientes opciones:

Ahora, para analizar los datos, utilizo Volatility en mi máquina debian; para ello, especifico el fichero que he creado con FTK Imager al utilizar los comandos.

1. Procesos en ejecución

Uso el comando pslist para ver los procesos en ejecución:

python vol.py -f "/media/roberto/usb/memdump.mem" windows.pslist.PsList

2. Servicios en ejecución

Uso el comando getservicesids para ver los servicios en ejecución:

python vol.py -f "/media/roberto/usb/memdump.mem" windows.getservicesids.GetServiceSIDs

3. Puertos abiertos

Uso el comando netstat para ver los puertos abiertos:

python vol.py -f "/media/roberto/usb/memdump.mem" windows.netstat.NetStat

4. Conexiones establecidas por la máquina

Uso el comando netscan para ver las conexiones establecidas por la máquina:

python vol.py -f "/media/roberto/usb/memdump.mem" windows.netscan.NetScan

5. Sesiones de usuario establecidas remotamente

Uso el comando sessions para ver las sesiones de usuario establecidas remotamente:

python vol.py -f "/media/roberto/usb/memdump.mem" windows.sessions.Sessions

6. Ficheros transferidos recientemente por NetBios

7. Contenido de la caché DNS

8. Variables de entorno

Para ver las variables de entorno, uso el comando envars:

python vol.py -f "/media/roberto/usb/memdump.mem"  windows.envars.Envars

Volcado del registro

Para realizar el volcado de registro he usado también la herramienta FTK Imager. Utilizo la opción Obtain system files:

Una vez finalizado el volcado, utilizo el programa Registry Viewer para analizar los datos obtenidos.

10. Redes wifi utilizadas recientemente

Para ver las redes wifi usadas recientemente, abro el archivo software, y ahí sigo la siguiente ruta: Microsoft/Windows NT/CurrentVersion/NetworkList/Profiles:

11. Configuración del firewall de nodo

Para ver la configuración del firewall de nodo, abro el archivo system, y ahí sigo la siguiente ruta: ControlSet001/Services/SharedAccess/Parameters/FirewallPolicy/FirewallRules:

12. Programas que se ejecutan en el Inicio

Para ver los programas que se ejecutan en el inicio, abro el archivo software, y ahí sigo la siguiente ruta: Microsoft/Windows/CurrentVersion/Run:

13. Asociación de extensiones de ficheros y aplicaciones

No he podido encontrar en la aplicación Registry Viewer los registros, pero usando regedit en la máquina, se encuentran en la siguiente localización: Computer\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts:

Volcado de disco

Para realizar el volcado de disco he usado la herramienta FTK Imager también:

Selecciono RAW como tipo de imagen:

Y, como indica la ayuda, en Fragment size pongo 0, además de indicar la ruta y el nombre del fichero:

El resto de los pasos del proceso los dejo con los valores por defecto.

Ahora, para analizar los datos, utilizo Autopsy; para ello, abro el fichero que he creado con FTK Imager, indicamos el direcorio del fichero , y en tipo, selecciono Disk image or VM file:

Tras finalizar la configuración, empezará a analizar el volcado de disco. Este proceso tarda bastante tiempo en completarse. Una vez acabado podemos analizar los datos obtenidos.

9. Dispositivos USB conectados

Para ver los dispositivos USB conectados, utilizo la opción USB Device Attached:

14. Aplicaciones usadas recientemente

Para ver las aplicaciones usadas recientemente, utilizo la opción User Activity del disco duro:

15. Ficheros abiertos recientemente

16. Software Instalado

Para ver el software instalado, utilizo la opción Installed Programs:

18. Cuentas de Usuario

Para ver las cuentas de usuario, utilizo la opción OS Accounts:

19. Historial de navegación y descargas, cookies

Para ver el historial de navegación, utilizo la opción Web History:

Para ver las cookies utilizo la opción Web Cookies:

Para ver el historial de descargas, utilizo la opción Web Downloads:

21. Archivos con extensión cambiada

Los archivos con extensión cambiada aparecen en la sección Analysis Results/Extension Mismatch Detected:

22. Archivos eliminados

Los archivos eliminados aparecen en la sección Recycle Bin:

23. Archivos Ocultos

En la opción para explorar el sistema de archivos, se pueden distinguir los archivos ocultos porque en los metadatos, aparece la etiqueta: Hidden:

24. Archivos que contienen una cadena determinada

Para buscar archivos que contengan una cadena determinada, utilizo la opción Keyword Search:

25. Búsqueda de imágenes por ubicación

Para buscar imágenes por ubicación, utilizo la opción Geolocation:

26. Búsqueda de archivos por autor

Para buscar archivos por autor, utilizo la opción Metadata:

Apartado B) Máquina Linux

Intenta realizar las mismas operaciones en una máquina Linux para aquellos apartados que tengan sentido y no se realicen de manera idéntica a Windows.

Volcado de memoria

He realizado el volcado de memoria con Lime, que es una herramienta que se utiliza para realizar volcados de memoria en Linux. Para ello, he usado el comando de la siguiente manera (he instalado Lime meadiante su repositorio en github):

insmod lime-4.19.0-23-amd64.ko "path=/mnt/linux/memorialinux.mem format=lime"

Es importante que para realizar el volcado, hay que iniciar el sistema de forma insegura, ya que si no, no permite utilizar el comando.

No he sido capaz de realizar el análisis utilizando volatility, ya que es necesario instalar plugins para interpretar el volcado de memoria, y no los reconoce, por lo que voy a usar los comandos en lugar de trabajar sobre el volcado.

1. Procesos en ejecución

Para ver los procesos en ejecución, utilizo el comando ps aux:

2. Servicios en ejecución

Para ver los servicios en ejecución, utilizo el comando systemctl:

systemctl list-units --type=service --state=running

3. Puertos abiertos

Para ver los puertos abiertos, utilizo el comando netstat, que se encuentra en el paquete net-tools:

apt install net-tools
netstat -tulpn

4. Conexiones establecidas por la máquina

Las sesiones se pueden observar en el comando netstat utilizado anteriormente.

5. Sesiones de usuario establecidas remotamente

Para ver las sesiones de usuario establecidas remotamente, utilizo el comando who:

who -a

7. Contenido de la caché DNS

En debian, la caché dns está deshabilitada por defecto. Para habilitarla, voy a instalar el paquete nscd (demonio de caché para servicio de nombres), y leer el fichero que genera. El fichero tiene un formato binario, por lo que voy a usar el comando strings para ver su contenido:

strings /var/cache/nscd/hosts

8. Variables de entorno

Para ver las variables de entorno, utilizo el comando env:

Volcado de disco

El volcado de disco en linux lo he realizado con el comando dd, que se utiliza para copiar archivos y volúmenes. Para ello, he usado el comando de la siguiente manera:

dd if=/dev/vda2 of=/mnt/linux/volcado_linux.001 bs=64K

Es imporate que, durante el análisis de la imagen en Autopsy, el tiempo es mucho mayor, y que es de hecho la última fase, cuando ya se encuentra al 100% la que toma más tiempo.

Los apartados rellativos al análisis usando autopsy, o se realizan exactamente igual que en Windows, o no tienen sentido en Linux, por lo que no los están documentados aquí.

Práctica: Servidor de correos

Tue, 07 Feb 2023 00:00:00 GMT

Gestión de correo desde el servidor

Tarea 1

Documenta una prueba de funcionamiento, donde envíes desde tu servidor local al exterior. Muestra el log donde se vea el envío. Muestra el correo que has recibido. Muestra el registro SPF.

Creo las siguientes entradas en el DNS de mi dominio:

Donde hay un registro MX que apunta a mail.admichin.es, que a su vez es un registro A que apunta a la IP de mi servidor. Además, hay un registro SPF que apunta a la ip de la máquina.

Además, configuro resolución inversa en la configuración de la VPS:

Ahora, en la VPS instalo los siguientes paquetes:

apt update
apt install postfix bsd-mailx -y

Durante la configuración, selecciono Internet Site y admichin.es.

Envío un correo a mi cuenta personal:

mail robertorodriguezmarquez98@gmail.com
Subject: Prueba de funcionamiento
Hola buenos días
Cc:

Vemos el log de postfix:

tail /var/log/mail.log

Y el correo recibido:

Tarea 2

Documenta una prueba de funcionamiento, donde envíes un correo desde el exterior (gmail, hotmail,…) a tu servidor local. Muestra el log donde se vea el envío. Muestra cómo has leído el correo. Muestra el registro MX de tu dominio.

Ahora envío un correo desde mi cuenta personal a mi servidor:

Y compruebo que el correo ha llegado a mi servidor:

Y el log de postfix:

Uso de alias y redirecciones

Tarea 3

Usos de alias y redirecciones. Vamos a comprobar como los procesos del servidor pueden mandar correos para informar sobre su estado. Por ejemplo cada vez que se ejecuta una tarea cron podemos enviar un correo informando del resultado. Normalmente estos correos se mandan al usuario root del servidor, para ello:

 crontab -e

E indico donde se envía el correo:

MAILTO=root

Puedes poner alguna tarea en el cron para ver como se mandan correo.

Posteriormente usando alias y redirecciones podemos hacer llegar esos correos a nuestro correo personal.

Configura el cron para enviar correo al usuario root. Comprueba que están llegando esos correos al root. Crea un nuevo alias para que se manden a un usuario sin privilegios. Comprueban que llegan a ese usuario. Por último crea una redirección para enviar esos correo a tu correo personal (gmail,hotmail,…).

Voy a crear un script que muestre la fecha y el espacio en el disco. Lo guardo en /root/script-espacio.sh:

#!/bin/bash

echo "##################################"
echo "Fecha y hora: $(date)"
echo "##################################"
echo "Espacio en el disco:"
df -h

Ahora creamos la tarea de cron para que se ejecute cada 5 minutos:

crontab -e

Y añadimos las siguientes líneas:

MAILTO = root

*/5 * * * * /root/script-espacio.sh

Cuando pasan 5 minutos, recibimos el correo:

Ahora voy a crear un alias para que se envíen los correos a un usuario sin privilegios (en este caso, calcetines), editando el fichero /etc/aliases:

root: calcetines

Y ejecuto el comando newaliases para que se actualicen los alias.

Ahora, cuando pasen 5 minutos, recibimos el correo en el usuario sin privilegios:

Ahora voy a crear una redirección para que se envíen los correos a mi correo personal, editando el fichero /home/calcetines/.forward:

robertorodriguezmarquez98@gmail.com

Y ahora, cuando pasen 5 minutos, recibimos el correo en mi correo personal:

Para asegurar el envío

Tarea 4

Configura de manera adecuada DKIM es tu sistema de correos. Comprueba el registro DKIM en la página https://mxtoolbox.com/dkim.aspx. Configura postfix para que firme los correos que envía. Manda un correo y comprueba la verificación de las firmas en ellos. }

Voy a instalar el paquete opendkim:

apt install opendkim opendkim-tools -y

En el fichero /etc/opendkim.conf, edito las siguientes líneas:

Domain                  admichin.es
Selector                default
KeyFile                 /etc/opendkim/keys/admichin.es/default.private
#Socket                 local:/run/opendkim/opendkim.sock
Socket                  local:/var/spool/postfix/opendkim/opendkim.sock
PidFile                 /run/opendkim/opendkim.pid
TrustAnchorFile         /usr/share/dns/root.key

Ahora añado el socket en el fichero /etc/default/opendkim.

Tras eso, en el fichero /etc/postfix/main.cf, añado las siguientes líneas:

milter_default_action = accept
milter_protocol = 6
smtpd_milters = local:opendkim/opendkim.sock
non_smtpd_milters = $smtpd_milters

Ahora genero los ficheros de claves:

mkdir /etc/opendkim/keys/admichin.es
cd /etc/opendkim/keys/admichin.es
opendkim-genkey -b 2048 -d admichin.es -D /etc/opendkim/keys/admichin.es -s default -v

Ahora, utilizando el contenido de /etc/opendkim/keys/admichin.es/default.txt, añado un registro TXT en el dominio admichin.es:

Reinicio los servicios:

systemctl restart opendkim postfix

Ahora, cuando envío un correo, se añade la firma DKIM:

Finalmente, compruebo la verificación de la firma en la página mxtoolbox:

Para luchar contra el spam

Gestión de correos desde un cliente

Tarea 8

Configura el buzón de los usuarios de tipo Maildir. Envía un correo a tu usuario y comprueba que el correo se ha guardado en el buzón Maildir del usuario del sistema correspondiente. Recuerda que ese tipo de buzón no se puede leer con la utilidad mail.

Voy a cambiar el tipo de buzón de los usuarios, editando el fichero /etc/postfix/main.cf:

home_mailbox = Maildir/

Ahora instalamos el cliente mutt para poder leer los correos:

apt install mutt -y
systemctl restart postfix

Tengo que hacer la siguiente configuración en cada usuario:

nano ~/.muttrc

set mbox_type=Maildir
set mbox="~/Maildir"
set folder="~/Maildir"
set spoolfile="~/Maildir"
set record="+.Sent"
set postponed="+.Drafts"
set mask="!^\\.[^.]"

Podemos ver el contenido del directorio Maildir:

Ahora, cuando envío un correo, se guarda en el buzón Maildir del usuario del sistema correspondiente, y lo podemos leer con mutt:

Tarea 9

Instala configura dovecot para ofrecer el protocolo IMAP. Configura dovecot de manera adecuada para ofrecer autentificación y cifrado.

Instalo dovecot:

apt install dovecot-imapd -y

Modifico el fichero /etc/dovecot/conf.d/10-ssl.conf para añadir el certificado que generamos con certbot al crear la página, modificando las siguientes líneas:

ssl_cert = </etc/letsencrypt/live/admichin.es-0001/fullchain.pem
ssl_key = </etc/letsencrypt/live/admichin.es-0001/privkey.pem

Ahora cambiamos la localización de los mailbox en el fichero /etc/dovecot/conf.d/10-mail.conf:

mail_location = maildir:~/Maildir

Tarea 10

Instala un webmail (roundcube, horde, rainloop) para gestionar el correo del equipo mediante una interfaz web. Muestra la configuración necesaria y cómo eres capaz de leer los correos que recibe tu usuario.

Voy a instalar roundcube utilizando docker:

apt install docker.io -y

Creo una entrada de tipo CNAME con el nombre webmail:

Ahora vamos a crear la configuración en un directorio que montaremos posteriormente por medio de bind mount en el docker;

mkdir /root/cuboredondo
nano -cl /root/cuboredondo/custom.inc.php

<?php
$config['mail_domain'] = array(
    'mail.admichin.es' => 'admichin.es'
);
?>

Ahora creo el contenedor de docker:

docker run -d --name docker-cuboredondo \
-v /root/cuboredondo/:/var/roundcube/config/ \
-e ROUNDCUBEMAIL_DEFAULT_HOST=ssl://mail.admichin.es \
-e ROUNDCUBEMAIL_SMTP_SERVER=ssl://mail.admichin.es \
-e ROUNDCUBEMAIL_SMTP_PORT=465 \
-e ROUNDCUBEMAIL_DEFAULT_PORT=993 \
-p 8001:80 \ 
roundcube/roundcubemail

o en una sola linea:

docker run -d --name docker-cuboredondo -v /root/cuboredondo/:/var/roundcube/config/ -e ROUNDCUBEMAIL_DEFAULT_HOST=ssl://mail.admichin.es -e ROUNDCUBEMAIL_SMTP_SERVER=ssl://mail.admichin.es -e ROUNDCUBEMAIL_SMTP_PORT=465 -e ROUNDCUBEMAIL_DEFAULT_PORT=993 -p 8001:80 roundcube/roundcubemail

Ahora creo el virtualhost para el dominio en /etc/nginx/sites-available/webmail.admichin.es:

server {
        listen 80;
        listen [::]:80;

        server_name webmail.admichin.es;

        return 301 https://$host$request_uri;
}

server {
        listen 443 ssl http2;
        listen [::]:443 ssl http2;

        ssl    on;
        ssl_certificate /etc/letsencrypt/live/admichin.es-0001/fullchain.pem;
        ssl_certificate_key     /etc/letsencrypt/live/admichin.es-0001/privkey.pem;

        index index.html index.php index.htm index.nginx-debian.html;

        server_name webmail.admichin.es;

        location / {
                proxy_pass http://localhost:8001;
                include proxy_params;
        }
}

Ahora activo el sitio y reinicio nginx:

ln -s /etc/nginx/sites-available/webmail.admichin.es /etc/nginx/sites-enabled/
systemctl restart nginx

Ahora podemos acceder a la instancia de roundcube desde el navegador:

Como se puede ver acabo de recibir el correo del ejercicio de la tarea del cron. Ahora un correo enviado desde fuera:

Tarea 11

Configura de manera adecuada postfix para que podamos mandar un correo desde un cliente remoto. La conexión entre cliente y servidor debe estar autentificada con SASL usando dovecor y además debe estar cifrada. Para cifrar esta comunicación puedes usar dos opciones:

ESMTP + STARTTLS: Usando el puerto 567/tcp enviamos de forma segura el correo al servidor.
SMTPS: Utiliza un puerto no estándar (465) para SMTPS (Simple Mail Transfer Protocol Secure). No es una extensión de smtp. Es muy parecido a HTTPS.

Elige una de las opciones anterior para realizar el cifrado. Y muestra la configuración de un cliente de correo (evolution, thunderbird, …) y muestra como puedes enviar los correos.

Usaré los mismos certificados que he generado antes para cifrar los emails que envío y recibo. Para ello, modifico la configuración de postfix en /etc/postfix/main.cf:

smtpd_tls_cert_file = /etc/letsencrypt/live/admichin.es-0001/fullchain.pem
smtpd_tls_key_file = /etc/letsencrypt/live/admichin.es-0001/privkey.pem

smtpd_sasl_auth_enable = yes
smtpd_sasl_type = dovecot
smtpd_sasl_path = private/auth
smtpd_sasl_authenticated_header = yes
broken_sasl_auth_clients = yes

Ahora edito /etc/postfix/master.cf:

submission inet n       -       y       -       -       smtpd
  -o content_filter=spamassassin
  -o syslog_name=postfix/submission
  -o smtpd_tls_security_level=encrypt
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_tls_auth_only=yes
  -o smtpd_reject_unlisted_recipient=no
  -o smtpd_client_restrictions=$mua_client_restrictions
  -o smtpd_helo_restrictions=$mua_helo_restrictions
  -o smtpd_sender_restrictions=$mua_sender_restrictions
  -o smtpd_recipient_restrictions=
  -o smtpd_relay_restrictions=permit_sasl_authenticated,reject
  -o milter_macro_daemon_name=ORIGINATING

smtps     inet  n       -       y       -       -       smtpd
  -o syslog_name=postfix/smtps
  -o smtpd_tls_wrappermode=yes
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_reject_unlisted_recipient=no
  -o smtpd_client_restrictions=$mua_client_restrictions
  -o smtpd_helo_restrictions=$mua_helo_restrictions
  -o smtpd_sender_restrictions=$mua_sender_restrictions
  -o smtpd_recipient_restrictions=
  -o smtpd_relay_restrictions=permit_sasl_authenticated,reject
  -o milter_macro_daemon_name=ORIGINATING

Le indico a dovecot como debe realizar la auntentificación en el fichero /etc/dovecot/conf.d/10-master.conf:

service auth {
  ...
  # Postfix smtp-auth
  unix_listener /var/spool/postfix/private/auth {
    mode = 0666
  }
  ...
}

Ahora hay que abrir los puertos 465 y 993 en la vps. Tras eso, reiniciamos el servicio:

systemctl restart postfix dovecot

Ahora configuramos el cliente de correo evolution:

Tras configurarlo probamos la recepción de un correo:

Y el envío:

Tarea 12

Configura el cliente webmail para el envío de correo. Realiza una prueba de envío con el webmail.

Esta tarea consiste en poder enviar correos desde el cliente roundcube, y se han realizado las configuraciones necesarias en la tarea 10. Ahora solo queda probarlo:

Comprobación final

Tarea 13

Prueba de envío de correo. En esta página tenemos una herramienta completa y fácil de usar a la que podemos enviar un correo para que verifique y puntúe el correo que enviamos. Captura la pantalla y muestra la puntuación que has sacado.

Enviamos un correo para comprobar la puntuación:

Integridad, firmas y autenticación

Mon, 30 Jan 2023 00:00:00 GMT

Tarea 1: Firmas electrónicas

Manda un documento y la firma electrónica del mismo a un compañero. Verifica la firma que tu has recibido.

echo "DOCUMENTO CIFRADO SECRETO" > documento_rober.txt\n
gpg --output firmarober.sig --detach-sig documento_rober.txt

Envío los ficheros por correo.

¿Qué significa el mensaje que aparece en el momento de verificar la firma?

Significa que, aunque el fichero está firmado por esa firma, no se puede asegurar que la firma pertenezca a la persona que dice ser.

Vamos a crear un anillo de confianza entre los miembros de nuestra clase, para ello.
- Tu clave pública debe estar en un servidor de claves
- Escribe tu fingerprint en un papel y dárselo a tu compañero, para que puede descargarse tu clave pública.
- Te debes bajar al menos tres claves públicas de compañeros. Firma estas claves.
- Tu te debes asegurar que tu clave pública es firmada por al menos tres compañeros de la clase.
- Una vez que firmes una clave se la tendrás que devolver a su dueño, para que otra persona se la firme.
- Cuando tengas las tres firmas sube la clave al servidor de claves y rellena tus datos en la tabla Claves públicas PGP 2020-2021
- Asegurate que te vuelves a bajar las claves públicas de tus compañeros que tengan las tres firmas.
Muestra las firmas que tiene tu clave pública.

Listamos las firmas con el comando gpg --list-sigs

Comprueba que ya puedes verificar sin “problemas” una firma recibida por una persona en la que confías.

Como se puede ver en la imagen anterior, nuestra firma está verificada por Antonio, y viceversa. Por lo que podemos verificar sin problemas un documento firmado por Antonio.

Comprueba que puedes verificar con confianza una firma de una persona en las que no confías, pero sin embargo si confía otra persona en la que tu tienes confianza total.

Ahora, vamos a utilizar un fichero firmado por María Jesús, en la que no confiamos directamente, pero en la que sí tiene confianza plena Antonio:

Tarea 3: Integridad de ficheros

Para validar el contenido de la imagen CD, solo asegúrese de usar la herramienta apropiada para sumas de verificación. Para cada versión publicada existen archivos de suma de comprobación con algoritmos fuertes (SHA256 y SHA512); debería usar las herramientas sha256sum o sha512sum para trabajar con ellos.

Verifica que el contenido del hash que has utilizado no ha sido manipulado, usando la firma digital que encontrarás en el repositorio. Puedes encontrar una guía para realizarlo en este artículo: How to verify an authenticity of downloaded Debian ISO images

wget https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/debian-11.6.0-amd64-netinst.iso
wget https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/SHA256SUMS
sha256sum -c SHA256SUMS 2> /dev/null | grep netinst

Tarea 4: Integridad y autenticidad

Busca información sobre apt secure y responde las siguientes preguntas:

¿Qué software utiliza apt secure para realizar la criptografía asimétrica?

Utiliza GnuPG para realizar la criptografía asimétrica.

¿Para que sirve el comando apt-key? ¿Qué muestra el comando apt-key list?

El comando apt-key sirve para administrar las claves de los repositorios de paquetes. El comando apt-key list muestra las claves de los repositorios de paquetes.

En que fichero se guarda el anillo de claves que guarda la herramienta apt-key?

El anillo de claves se guarda en el fichero /etc/apt/trusted.gpg.

¿Qué contiene el archivo Release de un repositorio de paquetes?. ¿Y el archivo Release.gpg?. Puedes ver estos archivos en el repositorio http://ftp.debian.org/debian/dists/Debian10.1/. Estos archivos se descargan cuando hacemos un apt update.

El archivo Release contiene la lista de paquetes que contiene el repositorio de paquetes. El archivo Release.gpg contiene la firma digital del archivo Release.

Explica el proceso por el cual el sistema nos asegura que los ficheros que estamos descargando son legítimos.

El sistema nos asegura que los ficheros que estamos descargando son legítimos mediante la verificación de la firma digital del fichero Release que se encuentra en el repositorio de paquetes.

añade de forma correcta el repositorio de virtualbox añadiendo la clave pública de virtualbox como se indica en la documentación.

Se hace con los siguientes comandos:

echo "deb https://download.virtualbox.org/virtualbox/debian buster contrib" >> /etc/apt/sources.list
wget -q https://www.virtualbox.org/download/oracle\_vbox\_2016.asc -O- | apt-key add -
wget -q https://www.virtualbox.org/download/oracle\_vbox.asc -O- | apt-key add -

Tras esto, se puede instalar virtualbox con el comando apt install virtualbox.

Tarea 5: Autentificación: ejemplo SSH

Explica los pasos que se producen entre el cliente y el servidor para que el protocolo cifre la información que se transmite? ¿Para qué se utiliza la criptografía simétrica? ¿Y la asimétrica?

Los pasos que se producen entre el cliente y el servidor para que el protocolo cifre la información que se transmite son los siguientes:

Se lleva a cabo un 'handshake' (apretón de manos) encriptado para que el cliente pueda verificar que se está comunicando con el servidor correcto
La capa de transporte de la conexión entre el cliente y la máquina remota es encriptada mediante un código simétrico
El cliente se autentica ante el servidor.
El cliente remoto interactua con la máquina remota sobre la conexión encriptada.

La criptografía simétrica se utiliza para encriptar la información que se transmite entre el cliente y el servidor. La criptografía asimétrica se utiliza para autentificar al cliente y al servidor.

Explica los dos métodos principales de autentificación: por contraseña y utilizando un par de claves públicas y privadas.

Los dos métodos principales de autentificación son:

Por contraseña: el cliente envía la contraseña al servidor para que este pueda autentificar al cliente.
Por par de claves públicas y privadas: el cliente envía su clave pública al servidor para que este pueda autentificar al cliente. El cliente envía su clave privada al servidor para que este pueda autentificar al cliente.

En el cliente para que sirve el contenido que se guarda en el fichero ~/.ssh/know_hosts?

El contenido que se guarda en el fichero ~/.ssh/know_hosts sirve para que el cliente pueda autentificar al servidor.

¿Qué significa este mensaje que aparece la primera vez que nos conectamos a un servidor?

 $ ssh debian@172.22.200.74
 The authenticity of host '172.22.200.74 (172.22.200.74)' can't be established.
 ECDSA key fingerprint is SHA256:7ZoNZPCbQTnDso1meVSNoKszn38ZwUI4i6saebbfL4M.
 Are you sure you want to continue connecting (yes/no)?

Implica que la conexión es nueva y que el cliente no tiene guardada la clave pública del servidor. Por lo tanto, el cliente no puede autentificar al servidor. El cliente pregunta al usuario si quiere continuar con la conexión.

En ocasiones cuando estamos trabajando en el cloud, y reutilizamos una ip flotante nos aparece este mensaje:

 $ ssh debian@172.22.200.74
 @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
 @    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
 @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
 IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
 Someone could be eavesdropping on you right now (man-in-the-middle attack)!
 It is also possible that a host key has just been changed.
 The fingerprint for the ECDSA key sent by the remote host is
 SHA256:W05RrybmcnJxD3fbwJOgSNNWATkVftsQl7EzfeKJgNc.
 Please contact your system administrator.
 Add correct host key in /home/jose/.ssh/known_hosts to get rid of this message.
 Offending ECDSA key in /home/jose/.ssh/known_hosts:103
   remove with:
   ssh-keygen -f "/home/jose/.ssh/known_hosts" -R "172.22.200.74"
 ECDSA host key for 172.22.200.74 has changed and you have requested strict checking.

Significa que la clave pública que teníamos asociada a esa dirección IP ha cambiado. Por lo tanto, el cliente no puede autentificar al servidor. Por lo que podría implicar que se está suplantando su identidad. Si aún así queremos continuar, hay que ejecutar el comando ssh-keygen -f "/home/jose/.ssh/known_hosts" -R "172.22.200.74"

¿Qué guardamos y para qué sirve el fichero en el servidor ~/.ssh/authorized_keys?

En ese fichero se guardan las claves públicas de los clientes que pueden acceder al servidor. Sirve para que el servidor pueda autentificar a los clientes.

Redes Privadas Virtuales con WireGuard

Thu, 26 Jan 2023 00:00:00 GMT

Caso C: VPN de acceso remoto con WireGuard

Monta una VPN de acceso remoto usando Wireguard. Intenta probarla con clientes Windows, Linux y Android. Documenta el proceso adecuadamente y compáralo con el del apartado A.

El Escenario es el siguiente:

Vamos a utilizar un VagrantFile igual al utilizado en el caso A para montar la infraestructura necesaria para la práctica:

Vagrant.configure("2") do |config|

config.vm.synced_folder ".", "/vagrant", disabled: true

  config.vm.define :cliente3 do |cliente3|
    cliente3.vm.box = "debian/bullseye64"
    cliente3.vm.hostname = "cliente3"
    cliente3.vm.network :private_network,
      :libvirt__network_name => "red-externa3",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.20",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :servidor3 do |servidor3|
    servidor3.vm.box = "debian/bullseye64"
    servidor3.vm.hostname = "servidor3"
    servidor3.vm.network :private_network,
      :libvirt__network_name => "red-externa3",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.10",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
    servidor3.vm.network :private_network,
      :libvirt__network_name => "red-interna3",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.1.10",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :maquina3 do |maquina3|
    maquina3.vm.box = "debian/bullseye64"
    maquina3.vm.hostname = "maquina3"
    maquina3.vm.network :private_network,
      :libvirt__network_name => "red-interna3",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.1.30",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end
end

Ahora vamos a configurar las máquinas:

Servidor

Instalamos wireguard:

sudo apt update
sudo apt install wireguard

Activamos el bit de forwarding en el servidor editando el fichero /etc/sysctl.conf y descomentando la siguiente línea:

net.ipv4.ip_forward=1

y hacemos los cambios efectivos:

sudo sysctl -p

Ahora vamos a generar los pares de claves para el servidor (como usuario root):

wg genkey | tee /etc/wireguard/server_private.key | wg pubkey | tee /etc/wireguard/server_public.key

Ahora vamos a crear el fichero de configuración del servidor en /etc/wireguard/wg0.conf, utilizando las claves que hemos generado en el paso anterior:

[Interface]
Address = 10.99.99.1/24
ListenPort = 51820
PrivateKey = aB9gyJdOH835WVK4bqbb2VqrGeW5wFuOIyHFx7suu1w=

Al tratarse de fichero sensibles, tienen que tener permisos de solo lectura, por lo que vamos a cambiar los permisos:

sudo chmod -R 600 /etc/wireguard/

Creamos la interfaz:

sudo wg-quick up /etc/wireguard/wg0.conf

Cliente

Instalamos wireguard:

sudo apt update
sudo apt install wireguard

Ahora vamos a generar los pares de claves para el cliente (como usuario root):

wg genkey | tee /etc/wireguard/client_private.key | wg pubkey | tee /etc/wireguard/client_public.key

hora vamos a crear el fichero de configuración del cliente en /etc/wireguard/wg0.conf, utilizando la clave privada generada en el paso anterior y la clave pública del servidor:

[Interface]
Address = 10.99.99.2/24
PrivateKey = 8DFSQc0qbT3P9Dhnbg44bxU+W2uRraXsebB+suQH+nQ=

[Peer]
PublicKey = voKHGdJUz8B6Q6jRYJspzhSWDLmXI4jroPc89VkMCHQ=
AllowedIPs = 0.0.0.0/0
Endpoint = 192.168.0.10:51820
PersistentKeepalive = 25

Al tratarse de fichero sensibles, tienen que tener permisos de solo lectura, por lo que vamos a cambiar los permisos:

sudo chmod -R 600 /etc/wireguard/

Creamos la interfaz:

sudo wg-quick up /etc/wireguard/wg0.conf

Una vez hecho esto, tenemos que añadir la clave pública del cliente al fichero de configuración del servidor, añadiendo las siguentes líneas:

[Peer]
PublicKey = eh7Ap8nkBQf5vL60sp2ORzqLtz2YWnbjABbTMrukaCo=
AllowedIPs = 10.99.99.2/32

y reiniciamos la interfaz:

sudo wg-quick down /etc/wireguard/wg0.conf
sudo wg-quick up /etc/wireguard/wg0.conf

Podemos ver el estado de la interfez con el comando wg:

Rutas

Para que los mensajes que se envíen desde la máquina cliente a la máquina servidor, pasen por el túnel VPN, tenemos que cambiar la ruta por defecto para que sea a través del servidor:

sudo ip route del default
sudo ip route add default via 10.99.99.1

Tenemos que cambiar la ruta por defecto también de la máquina interna para que sea a través del servidor:

sudo ip route del default
sudo ip route add default via 192.168.1.10

Comprobación

Para comprobar que funciona, vamos a hacer un traceroute desde la máquina cliente a la máquina servidor:

Caso D: VPN sitio a sitio con WireGuard

Configura una VPN sitio a sitio usando WireGuard. Documenta el proceso adecuadamente y compáralo con el del apartado B.

El Escenario es el siguiente:

El escenario es similar al del caso B por lo que utilizaremos el mismo vagrantfile:

Vagrant.configure("2") do |config|

config.vm.synced_folder ".", "/vagrant", disabled: true

  config.vm.define :maquina1 do |maquina1|
    maquina1.vm.box = "debian/bullseye64"
    maquina1.vm.hostname = "maquina1"
    maquina1.vm.network :private_network,
      :libvirt__network_name => "interna1",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.20",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :cliente do |cliente|
    cliente.vm.box = "debian/bullseye64"
    cliente.vm.hostname = "cliente"
    cliente.vm.network :private_network,
      :libvirt__network_name => "interna1",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.10",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
    cliente.vm.network :private_network,
      :libvirt__network_name => "internet",
      :libvirt__dhcp_enabled => false,
      :ip => "10.20.30.1",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :servidor do |servidor|
    servidor.vm.box = "debian/bullseye64"
    servidor.vm.hostname = "servidor"
    servidor.vm.network :private_network,
      :libvirt__network_name => "internet",
      :libvirt__dhcp_enabled => false,
      :ip => "10.20.30.2",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
    servidor.vm.network :private_network,
      :libvirt__network_name => "interna2",
      :libvirt__dhcp_enabled => false,
      :ip => "172.22.0.10",
      :libvirt__netmask => '255.255.0.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :maquina2 do |maquina2|
    maquina2.vm.box = "debian/bullseye64"
    maquina2.vm.hostname = "maquina2"
    maquina2.vm.network :private_network,
      :libvirt__network_name => "interna2",
      :libvirt__dhcp_enabled => false,
      :ip => "172.22.0.20",
      :libvirt__netmask => '255.255.0.0',
      :libvirt__forward_mode => "veryisolated"
  end
end

Ahora vamos a configurar las máquinas:

Servidor

La configuración es similar a la del caso B, con la diferencia de que el fichero de configuración en /etc/wireguard/wg0.conf es el siguiente:

Las claves son:

privada: 0N0kdHNHajtKY78rAGaI5uHzY8QGvZMCuiyw3WXU0n0=
pública: SC7FuKTw2GnjJmJDmP0GuZGzgr9CBHUbcBOAXKKrCSU=

[Interface]
Address = 10.99.99.1
ListenPort = 51820
PrivateKey = 0N0kdHNHajtKY78rAGaI5uHzY8QGvZMCuiyw3WXU0n0=

Creamos la interfaz con el siguiente comando:

sudo wg-quick up wg0

Cliente

La configuración es similar a la del caso B, con la diferencia de que el fichero de configuración en /etc/wireguard/wg0.conf es el siguiente:

Las claves son:

privada: OLKDIsseCywbzWOwME1gxzIZLhopGljCeyYgibrHwm0=
pública: jwqTMNZ4lQkVk2OLrlMGZGDCkkCLJFmcUjlF7aPvrWc=

[Interface]
Address = 10.99.99.2
PrivateKey = OLKDIsseCywbzWOwME1gxzIZLhopGljCeyYgibrHwm0=
ListenPort = 51820

[Peer]
PublicKey = SC7FuKTw2GnjJmJDmP0GuZGzgr9CBHUbcBOAXKKrCSU=
AllowedIPs = 0.0.0.0/0
Endpoint = 10.20.30.2:51820

Creamos la interfaz con el siguiente comando:

sudo wg-quick up wg0

Activamos el bit de forwarding en el servidor editando el fichero /etc/sysctl.conf y descomentando la siguiente línea:

net.ipv4.ip_forward=1

y hacemos los cambios efectivos:

sudo sysctl -p

Ahora, como tenemos la clave pública del otro servidor, modificamos el fichero /etc/wireguard/wg0.conf del servidor para añadir la siguiente sección:

[Peer]
Publickey = jwqTMNZ4lQkVk2OLrlMGZGDCkkCLJFmcUjlF7aPvrWc=
AllowedIPs = 0.0.0.0/0
PersistentKeepAlive = 25
Endpoint = 10.20.30.1:51820

y reiniciamos el servicio:

sudo wg-quick down wg0
sudo wg-quick up wg0

Máquinas

Ahora vamos a configurar las rutas en las maquinas internas:

Máquina1:

sudo ip route del default
sudo ip route add default via 192.168.0.10

Máquina2:

sudo ip route del default
sudo ip route add default via 172.22.0.10

Prueba de funcionamiento

traceroute desde maquina1 a maquina2:

traceroute desde maquina2 a maquina1:

Conclusión

Utilizando WireGuard la configuración es más sencilla de realizar y tiene menos ficheros, por lo que es más fácil de gestionar y de depurar errores. Aparte de esto, el funcionamiento es el mismo que el de OpenVPN.

Introducción a OpenLDAP

Wed, 25 Jan 2023 00:00:00 GMT

El protocolo LDAP es muy utilizado actualmente por empresa que apuestan por el software libre al utilizar distribuciones de Linux para ejercer las funciones propias de un directorio activo en el que se gestionarán las credenciales y permisos de los trabajadores y estaciones de trabajo en redes LAN corporativas en conexiones cliente/servidor.

Realiza la instalación y configuración básica de OpenLDAP en alfa,utilizando como base el nombre DNS asignado. Deberás crear un usuario llamado prueba y configurar una máquina cliente basada en Debian y Rocky para que pueda validarse en servidor ldap configurado anteriormente con el usuario prueba.

Servidor

Instalación de OpenLDAP

Instalaremos OpenLDAP en el servidor alfa, para ello ejecutaremos los siguientes comandos:

apt update
apt install slapd

Durante la instalación nos pedirá que introduzcamos la contraseña de administrador del directorio:

Una vez instalado con el comando netstat -tulpn comprobaremos que el servicio está escuchando en el puerto 389:

Ahora, utilizando el binario ldapsearch incluido en el paquete ldap-utils podemos buscar sobre el directorio:

ldapsearch -x -b "dc=roberto,dc=gonzalonazareno,dc=org"

Configuración de OpenLDAP

Para lograr una mejor estructura, la información suele organizarse en forma de ramas de las que cuelgan objetos similares (por ejemplo, una rama para usuarios y otra para grupos). Organizar de esta manera la estructura nos aporta también una mayor agilidad en las búsquedas, así como una gestión más eficiente sobre los permisos. Cada rama se denomina organizational unit (OU) y cada objeto que cuelga de ella se denomina entry.

ara definir dichos objetos, haremos uso de un fichero con extensión .ldif, en este caso he creado el fichero unidades.ldif con el siguiente contenido:

dn: ou=Personas,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: organizationalUnit
ou: Personas 

dn: ou=Grupos,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: organizationalUnit
ou: Grupos

Para activar el fichero de configuración, ejecutaremos el siguiente comando:

ldapadd -x -D "cn=admin,dc=roberto,dc=gonzalonazareno,dc=org" -f unidades.ldif -W

Ahora, podemos comprobar que se ha creado las ramas Personas y Grupos:

ldapsearch -x -b "dc=roberto,dc=gonzalonazareno,dc=org"

Podemos borrar los objetos creados con el comando ldapdelete:

ldapdelete -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W ou=Personas,dc=roberto,dc=gonzalonazareno,dc=org
ldapdelete -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W ou=Grupos,dc=roberto,dc=gonzalonazareno,dc=org

Ahora vamos a crear un grupo llamado prueba en el fichero grupos.ldif:

dn: cn=prueba,ou=Grupos,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: posixGroup
gidNumber: 2001
cn: prueba

Para activar el fichero de configuración, ejecutaremos el siguiente comando:

ldapadd -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W -f grupos.ldif

Ejecutando el comando ldapsearch podemos comprobar que se ha creado el grupo:

Creación del usuario

Ahora vamos a crear un usuario llamado prueba. Antes de crearlo, vamos a ejecutar el comando slappasswd para crear una contraseña cifrada para el usuario:

Ahora, vamos a crear el usuario en el fichero usuarios.ldif:

dn: uid=prueba,ou=Personas,dc=roberto,dc=gonzalonazareno,dc=org
objectClass: posixAccount
objectClass: inetOrgPerson
objectClass: person
cn: prueba
uid: prueba
uidNumber: 2001
gidNumber: 2001
homeDirectory: /nfs/prueba
loginShell: /bin/bash
userPassword: {SSHA}sDPbVb9gQ37YaNSg5nPyIe776dmlU2bq
sn: prueba
mail: prueba@gmail.com
givenName: prueba

Para activar el fichero de configuración, ejecutaremos el siguiente comando:

ldapadd -x -D 'cn=admin,dc=roberto,dc=gonzalonazareno,dc=org' -W -f usuarios.ldif

Ejecutando el comando ldapsearch podemos comprobar que se ha creado el usuario:

Configuración de NFS

Ahora vamos a configurar el servidor NFS para que pueda compartir el directorio /nfs con los clientes.

Primero vamos a crear el directorio /nfs/prueba y le vamos a dar permisos al usuario prueba:

mkdir /nfs/prueba
chown 2001:2001 /nfs/prueba

Ahora vamos a editar el fichero /etc/exports y añadir la siguiente línea, que permite que el usuario prueba pueda acceder al directorio /nfs/prueba:

/nfs       *(rw,fsid=0,subtree_check)

Ahora vamos a reiniciar el servicio NFS:

systemctl restart nfs-server

Configuración final del servidor LDAP

Ahora vamos a configurar el servidor LDAP para que sea capaz de resolver nombres de grupos y de usuarios, consultar información a un directorio LDAP, identificarse o cachear la resolución de nombres.

Para ello, instalamos los siguientes paquetes:

apt install libpam-ldapd nscd libnss-ldap

Durante la instalación, dejamos los valores por defecto menos en las siguientes preguntas:

Como se indica al final de la instalación, vamos a editar el fichero /etc/nsswitch.conf y añadir las siguientes líneas:

passwd:         files ldap
group:          files ldap
shadow:         files ldap
gshadow:        files ldap

hosts:          files dns mymachines
networks:       files

protocols:      db files
services:       db files
ethers:         db files
rpc:            db files

netgroup:       nis

Reiniciamos el servicio nscd:

systemctl restart nscd

Ahora con el comando id prueba podemos comprobar que se resuelven los nombres:

Finalmente podemos iniciar sesión con el comando login prueba:

Cliente Ubuntu

Instalamos el siguiente paquete:

apt install ldap-utils

Ahora vamos a editar el fichero /etc/ldap/ldap.conf y añadir las siguientes líneas:

BASE dc=roberto,dc=gonzalonazareno,dc=org
URI ldap://alfa.roberto.gonzalonazareno.org

Después de esto, con el siguiente comando comprobamos que funciona correctamente:

ldapsearch -x -b "dc=roberto,dc=gonzalonazareno,dc=org"

Ahora vamos a instalar los paquetes para las resoluciones:

apt install libnss-ldap libpam-ldapd nscd

La instalación es similar a la del sevidor, dejando valores por defecto y cambiando los mismos, además de añadir un usuario sin privilegios.

Como se indica al final de la instalación, vamos a editar el fichero /etc/nsswitch.conf y añadir las siguientes líneas:

passwd:         files systemd ldap
group:          files systemd ldap
shadow:         files ldap 
gshadow:        files ldap

hosts:          files dns
networks:       files

protocols:      db files
services:       db files
ethers:         db files
rpc:            db files

netgroup:       nis

Reiniciamos el servicio nscd:

systemctl restart nscd

NFS

Ahora vamos a instalar el paquete nfs-common:

apt install nfs-common

Activamos el servicio

systemctl start nfs-client.target & systemctl enable nfs-client.target

Ahora vamos a crear los directorios que vamos a montar:

mkdir -p /home/nfs/prueba
chown 2001:2001 /home/nfs/prueba

Ahora vamos a montar la carpeta mediante NFS. Primero, cargamos el módulo

modprobe nfs

Con la siguiente línea se carga automáticamente:

echo NFS | tee -a /etc/modules

Y vamos a hacer un montaje mediante SystemD a través del fichero /etc/systemd/system/home-nfs.mount:

[Unit]
Description=script de montaje NFS
Requires=network-online.target
After=network-online.target
[Mount]
What=192.168.0.1:/nfs
Where=/home/nfs
Options=_netdev,auto
Type=nfs
[Install]
WantedBy=multi-user.target

Y lo activamos:

systemctl daemon-reload
systemctl start home-nfs.mount
systemctl enable home-nfs.mount

Tras esto, ya podremos entrar correctamente con login prueba. Podemos comprobar como los ficheros creados en el servidor se ven reflejados en el cliente:

Redes Privadas Virtuales con OpenVPN

Wed, 25 Jan 2023 00:00:00 GMT

Caso A: VPN de acceso remoto con OpenVPN y certificados x509

Uno de los dos equipos (el que actuará como servidor) estará conectado a dos redes
Para la autenticación de los extremos se usarán obligatoriamente certificados digitales, que se generarán utilizando openssl y se almacenarán en el directorio /etc/openvpn, junto con los parámetros Diffie-Helman y el certificado de la propia Autoridad de Certificación. * Se utilizarán direcciones de la red 10.99.99.0/24 para las direcciones virtuales de la VPN. La dirección 10.99.99.1 se asignará al servidor VPN.
Los ficheros de configuración del servidor y del cliente se crearán en el directorio /etc/openvpn de cada máquina, y se llamarán servidor.conf y cliente.conf respectivamente.
Tras el establecimiento de la VPN, la máquina cliente debe ser capaz de acceder a una máquina que esté en la otra red a la que está conectado el servidor. Documenta el proceso detalladamente.

El Escenario es el siguiente:

Vamos a generar dicho en Vagrant utilizando el siguiente Vagrantfile:

Vagrant.configure("2") do |config|

config.vm.synced_folder ".", "/vagrant", disabled: true

  config.vm.define :cliente do |cliente|
    cliente.vm.box = "debian/bullseye64"
    cliente.vm.hostname = "cliente"
    cliente.vm.network :private_network,
      :libvirt__network_name => "red-externa",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.20",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :servidor do |servidor|
    servidor.vm.box = "debian/bullseye64"
    servidor.vm.hostname = "servidor"
    servidor.vm.network :private_network,
      :libvirt__network_name => "red-externa",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.10",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
    servidor.vm.network :private_network,
      :libvirt__network_name => "red-interna",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.1.10",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :maquina do |maquina|
    maquina.vm.box = "debian/bullseye64"
    maquina.vm.hostname = "maquina"
    maquina.vm.network :private_network,
      :libvirt__network_name => "red-interna",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.1.30",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end
end

Ahora vamos a configurar las máquinas:

Configuración de la máquina servidor

Vamos a instalar OpenVPN en la máquina servidor:

apt-get update
apt-get install openvpn

Activamos el bit de forwarding en el servidor editando el fichero /etc/sysctl.conf y descomentando la siguiente línea:

net.ipv4.ip_forward=1

y hacemos los cambios efectivos:

sudo sysctl -p

Como indica el enunciado, hay que copiar los ficheros del directorio /usr/easy-rsa/ al directorio /etc/openvpn/:

cp -r /usr/share/easy-rsa /etc/openvpn

Ejecutamos el script de infraestructura de clave pública (PKI) para generar los certificados:

cd /etc/openvpn/easy-rsa
sudo ./easyrsa init-pki

Ahora podemos generar la clave privada:

sudo ./easyrsa build-ca

Se guardarán en el directorio /etc/openvpn/easy-rsa/pki/.

Ahora generamos el certificado del servidor:

sudo ./easyrsa build-server-full server nopass

Ahora vamos a generar los certificados diffie-helman (este proceso puede tardar varios minutos):

sudo ./easyrsa gen-dh

Por último, vamos a generar el certificado y la clave para la máquina cliente:

sudo ./easyrsa build-client-full cliente nopass

Como indica el comando, la clave se encuentra en /etc/openvpn/easy-rsa/pki/private/cliente.keyy el certificado en /etc/openvpn/easy-rsa/pki/issued/cliente.crt.

Ahora copiamos los ficheros del cliente a la máquina cliente:

primero los movemos al directorio home:

sudo cp /etc/openvpn/easy-rsa/pki/ca.crt ~
sudo mv /etc/openvpn/easy-rsa/pki/issued/cliente.crt ~
sudo mv /etc/openvpn/easy-rsa/pki/private/cliente.key ~

Cambiamos el propietario de los ficheros (aprovechando que los tres ficheros empiezan por c*):

sudo chown vagrant: c*

Y ahora los copiamos a la máquina (aprovechando también que los tres ficheros empiezan por c* para ahorrar código):

scp c* vagrant@cliente:/home/vagrant

utilizando como plantilla el fichero que se encuentra en /usr/share/doc/openvpn/examples/sample-config-files/server.conf, creamos el fichero de configuración del servidor en /etc/openvpn/server/servidor.conf:

port 1194
proto udp
dev tun

ca /etc/openvpn/easy-rsa/pki/ca.crt
cert /etc/openvpn/easy-rsa/pki/issued/server.crt
key /etc/openvpn/easy-rsa/pki/private/server.key
dh /etc/openvpn/easy-rsa/pki/dh.pem

topology subnet

# DIRECCIONAMIENTO PARA EL TÚNEL
#
# El servidor será: 10.99.99.1

server 10.99.99.0 255.255.255.0
ifconfig-pool-persist /var/log/openvpn/ipp.txt

push "route 192.168.1.0 255.255.255.0"

keepalive 10 120
cipher AES-256-CBC
persist-key
persist-tun
status /var/log/openvpn/openvpn-status.log
verb 3
explicit-exit-notify 1

Ahora activamos el servicio de OpenVPN:

sudo systemctl enable --now openvpn-server@servidor
sudo systemctl status openvpn-server@servidor

Configuración de la máquina cliente

Ahora vamos a configurar la máquina cliente. Primero instalamos OpenVPN:

sudo apt update
sudo apt install openvpn

Movemos los ficheros que hemos copiado de la máquina servidor a la máquina cliente a la ruta /etc/openvpn/client/:

sudo mv c* /etc/openvpn/client/
sudo chown root: /etc/openvpn/client/*

Al igual que con el servidor, tomando de ejemplo el fichero /usr/share/doc/openvpn/examples/sample-config-files/client.conf, creamos el fichero de configuración del cliente en /etc/openvpn/client/cliente.conf:

client
dev tun
proto udp
´
remote 192.168.0.10 1194
resolv-retry infinite
nobind

persist-key
persist-tun

ca /etc/openvpn/client/ca.crt
cert /etc/openvpn/client/cliente.crt
key /etc/openvpn/client/cliente.key

remote-cert-tls server
cipher AES-256-CBC
verb 3

Ahora activamos el servicio de OpenVPN:

sudo systemctl enable --now openvpn-client@cliente
sudo systemctl status openvpn-client@cliente

Configuración de la máquina interna

Tenemos que cambiar la ruta por defecto también de la máquina interna para que sea a través del servidor:

sudo ip route del default
sudo ip route add default via 192.168.1.10

Comprobación de funcionamiento

Ahora vamos a comprobar que funciona el túnel. En la máquina cliente, vamos a hacer un traceroute a la máquina de la red interna (de ip 192.168.1.30):

traceroute 192.168.1.30

Como podemos ver, el primer salto es a la máquina servidor utilizando el túnel VPN del servidor, y el segundo salto es a la máquina de la red interna.

Podemos incluso, realizar una conexión SSH a la máquina de la red interna:

Caso B: VPN sitio a sitio con OpenVPN y certificados x509

Cada equipo estará conectado a dos redes, una de ellas en común
- Para la autenticación de los extremos se usarán obligatoriamente certificados digitales, que se generarán utilizando openssl y se almacenarán en el directorio /etc/openvpn, junto con con los parámetros Diffie-Helman y el certificado de la propia Autoridad de Certificación.
- Se utilizarán direcciones de la red 10.99.99.0/24 para las direcciones virtuales de la VPN.
- Tras el establecimiento de la VPN, una máquina de cada red detrás de cada servidor VPN debe ser capaz de acceder a una máquina del otro extremo.

El Escenario es el siguiente:

Vamos a generar dicho en Vagrant utilizando el siguiente Vagrantfile:

Vagrant.configure("2") do |config|

config.vm.synced_folder ".", "/vagrant", disabled: true

  config.vm.define :maquina1 do |maquina1|
    maquina1.vm.box = "debian/bullseye64"
    maquina1.vm.hostname = "maquina1"
    maquina1.vm.network :private_network,
      :libvirt__network_name => "interna1",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.20",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :cliente do |cliente|
    cliente.vm.box = "debian/bullseye64"
    cliente.vm.hostname = "cliente"
    cliente.vm.network :private_network,
      :libvirt__network_name => "interna1",
      :libvirt__dhcp_enabled => false,
      :ip => "192.168.0.10",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
    cliente.vm.network :private_network,
      :libvirt__network_name => "internet",
      :libvirt__dhcp_enabled => false,
      :ip => "10.20.30.1",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :servidor do |servidor|
    servidor.vm.box = "debian/bullseye64"
    servidor.vm.hostname = "servidor"
    servidor.vm.network :private_network,
      :libvirt__network_name => "internet",
      :libvirt__dhcp_enabled => false,
      :ip => "10.20.30.2",
      :libvirt__netmask => '255.255.255.0',
      :libvirt__forward_mode => "veryisolated"
    servidor.vm.network :private_network,
      :libvirt__network_name => "interna2",
      :libvirt__dhcp_enabled => false,
      :ip => "172.22.0.10",
      :libvirt__netmask => '255.255.0.0',
      :libvirt__forward_mode => "veryisolated"
  end

  config.vm.define :maquina2 do |maquina2|
    maquina2.vm.box = "debian/bullseye64"
    maquina2.vm.hostname = "maquina2"
    maquina2.vm.network :private_network,
      :libvirt__network_name => "interna2",
      :libvirt__dhcp_enabled => false,
      :ip => "172.22.0.20",
      :libvirt__netmask => '255.255.0.0',
      :libvirt__forward_mode => "veryisolated"
  end
end

Ahora configuraremos las máquinas;

Configuración del servidor

La configuración es exactamente igual que en el caso anterior, por lo que tenemos que replicar la misma configuración (incluyendo copiar los ficheros al cliente) hasta el momento de editar el fichero /etc/openvpn/server/servidor.conf, donde empieza la configuración diferente.

Ahora creamos el fichero /etc/openvpn/server/servidor.conf con el siguiente contenido:

dev tun
ifconfig 10.99.99.1 10.99.99.2
route 192.168.0.0 255.255.255.0
tls-server

dh /etc/openvpn/easy-rsa/pki/dh.pem
ca /etc/openvpn/easy-rsa/pki/ca.crt
cert /etc/openvpn/easy-rsa/pki/issued/server.crt
key /etc/openvpn/easy-rsa/pki/private/server.key

comp-lzo
keepalive 10 60
log /var/log/openvpn/prueba.log

verb 3

sudo systemctl enable --now openvpn-server@servidor
sudo systemctl status openvpn-server@servidor

Configuración del cliente

Ahora vamos a configurar la máquina cliente. Primero instalamos OpenVPN:

sudo apt update
sudo apt install openvpn

Activamos el bit de forwarding en el servidor editando el fichero /etc/sysctl.conf y descomentando la siguiente línea:

net.ipv4.ip_forward=1

y hacemos los cambios efectivos:

sudo sysctl -p

Movemos los ficheros que hemos copiado de la máquina servidor a la máquina cliente a la ruta /etc/openvpn/client/:

sudo mv c* /etc/openvpn/client/
sudo chown root: /etc/openvpn/client/*

dev tun
remote 10.20.30.2
ifconfig 10.99.99.2 10.99.99.1
route 172.22.0.0 255.255.0.0
tls-client
ca /etc/openvpn/client/ca.crt
cert /etc/openvpn/client/cliente.crt
key /etc/openvpn/client/cliente.key
comp-lzo
keepalive 10 60
log /var/log/openvpn/cliente.log

verb 3

Ahora activamos el servicio de OpenVPN:

sudo systemctl enable --now openvpn-client@cliente
sudo systemctl status openvpn-client@cliente

Configuramos las máquinas internas

Ahora vamos a configurar las rutas en las maquinas internas:

Máquina1:

sudo ip route del default
sudo ip route add default via 192.168.0.10

Máquina2:

sudo ip route del default
sudo ip route add default via 172.22.0.10

Pruebas de funcionamiento

traceroute desde maquina1 a maquina2:

traceroute desde maquina2 a maquina1:

Despliegue de aplicaciones de java usando tomcat

Tue, 24 Jan 2023 00:00:00 GMT

Tarea 1 Desarrollo y despliegue de una aplicación Java simple

De forma similar a lo que hemos hecho en el Taller 1, desplegamos de forma manual la aplicación Java que encontramos en el repositorio https://github.com/josedom24/rock-paper-scissors

Una vez tenemos la carpeta, vamos a compilarla con el siguiente comando:

mvn package

Una vez compilada, vamos a desplegarla en el servidor Tomcat. Para ello, copiamos el fichero war que se ha generado en la carpeta target en la carpeta webapps del servidor Tomcat. Una vez copiado, reiniciamos el servidor Tomcat.

cp roshambo.war /var/lib/tomcat9/webapps/
systemctl restart tomcat9

Tarea 2 Despliegue de un CMS Java

Instalación de OpenCMS

Para instalar OpenCMS, vamos a descargar el fichero war de la página de descargas de OpenCMS. Una vez descargado, lo copiamos en la carpeta webapps de Tomcat.

scp -r opencms.war debian@172.22.200.19:/home/debian/

cp opencms.war /var/lib/tomcat9/webapps/
systemctl restart tomcat9

Instalamos la base de datos MariaDB y creamos la base de datos opencms.

apt install mariadb-server
sudo mysql -u root -p
CREATE DATABASE opencms;
CREATE USER 'java'@'localhost' IDENTIFIED BY 'java';
grant all privileges on opencms. * to 'java'@'localhost' with grant option;
flush privileges;

Una vez instalado, accedemos a la aplicación con la url http://172.22.200.19:8080/opencms/setup

Seguimos los pasos de la instalación, indicando la base de datos que hemos creado y el usuario java/java.

Tarea 3 Acceso a las aplicaciones

Instalamos nginx para realizar un proxy inverso para acceder a las aplicaciones.

apt install nginx

Y creamos el siguiente virtualhost en /etc/nginx/sites-available/opencms.conf:

server {
    listen 80;
    listen [::]:80;

    index index.html index.htm index.nginx-debian.html;

    server_name java.roberto.org;

    location / {
        return 301 http://$host/opencms/;
    }

    location /opencms/ {
        proxy_pass http://localhost:8080;
        include proxy_params;
    }

    location /game/ {
        proxy_pass http://localhost:8080/roshambo/;
        include proxy_params;
    }
}

Y lo activamos:

sudo ln -s /etc/nginx/sites-available/opencms.conf /etc/nginx/sites-enabled/
sudo systemctl restart nginx

Una vez hecho podemos acceder a las aplicaciones con las siguientes urls:

piedra papel tijera -> http://java.roberto.org/game/

opencms -> http://java.roberto.org/

Despliegue de aplicaciones python sobre django

Mon, 23 Jan 2023 00:00:00 GMT

Tarea 1 Entorno de desarrollo

He elegido como entorno de desarrollo la máquina bravo.

Primero creamos un entorno virtual de python3 e instalamos las dependencias necesarias para que funcione el proyecto.

python3 -m venv django 
source django/bin/activate
pip install django

Ahora descargamos el proyecto de github:

git clone https://github.com/robertorodriguez98/django_tutorial

Configuración de django

Comprobamos que vamos a trabajar con una base de datos sqlite. Para ello tenemos que consultar el fichero settings.py. En este caso la base de datos se llama db.sqlite3.

(django)$ cd django_tutorial
(django)$ cat django_tutorial/settings.py | egrep -A 5 'DATABASES';
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Para poder acceder desde la dirección www.roberto.gonzalonazareno.org, tenemos que modificar el fichero django_tutorial/settings.py y añadir la dirección a la lista de hosts permitidos de la siguiente manera:.

ALLOWED_HOSTS = ['www.roberto.gonzalonazareno.org']

Ahora creamos la base de datos:

(django)$ python manage.py migrate

Y el usuario administrador:

(django)$ python3 manage.py createsuperuser

Ahora ejecutamos el servidor web de desarrollo:

(django)$ python3 manage.py runserver 0.0.0.0:8000

Y accedemos a la zona de administración, en este caso en la dirección www.roberto.gonzalonazareno.org:8000/admin y añadimos dos preguntas con sus posibles respuestas.

Comprueba en el navegador que la aplicación está funcionando, accede a la url /polls.

Configuración del servidor web

En bravo, el servidor web apache2 ya está instalado y configurado para servir páginas web estáticas. Para servir páginas web dinámicas, tenemos que instalar el módulo wsgi.

sudo dnf install python3-mod_wsgi

Ahora, para que el entorno sea similar al de producción, movemos el proyecto y el entorno virtual a la ruta /var/www/html/django_tutorial y /var/www/html/django respectivamente.

sudo mv django_tutorial /var/www/html/
sudo mv django /var/www/html/

Creamos el contenido estático de la aplicación:

sudo python3 manage.py collectstatic

Editamos el fichero /var/www/html/django_tutorial/django_tutorial/settings.py y modificamos las siguientes líneas:

ALLOWED_HOSTS = ['*']
STATIC_ROOT = '/var/www/html/django_tutorial/static/'

Ahora configuraremos el servidor apache para que sirva la aplicación django. Para ello, tenemos que crear un fichero de configuración en la ruta /etc/httpd/sites-available/django.conf con el siguiente contenido:

<VirtualHost python.roberto.gonzalonazareno.org:80>
    ServerName python.roberto.gonzalonazareno.org
    DocumentRoot /var/www/html/django_tutorial

    Alias /static/ /var/www/html/django_tutorial/static/

    WSGIDaemonProcess django_tutorial python-path=/var/www/html/django_tutorial:/var/www/html/django/lib/python3.9/site-packages
    WSGIProcessGroup django_tutorial
    WSGIScriptAlias / /var/www/html/django_tutorial/django_tutorial/wsgi.py

    ErrorLog /var/log/httpd/django_tutorial_error.log
    CustomLog /var/log/httpd/django_tutorial_access.log combined
</VirtualHost>

Para que funcione la configuración tenemos que activar el sitio web y reiniciar el servidor web:

sudo ln -s /etc/httpd/sites-available/django.conf /etc/httpd/sites-enabled/django.conf
sudo systemctl restart httpd

Ahora podemos acceder a la aplicación desde la dirección python.roberto.gonzalonazareno.org.

Tarea 2: Entorno de producción

Vamos a realizar el despliegue de nuestra aplicación en un entorno de producción, para ello vamos a utilizar nuestro VPS, sigue los siguientes pasos:

Instalación de django y base de datos

Clonamos el repositorio:

git clone https://github.com/robertorodriguez98/django_tutorial

Creamos el entorno virtual:

python3 -m venv django 
source django/bin/activate
cd django_tutorial
pip install -r requirements.txt

Instalamos el módulo que permite que python trabaje con mysql:

sudo apt install libmariadb-dev
pip install mysqlclient

Tras crear un usuario y la base de datos, configuramos la aplicación para trabajar con mysql, para ello modifica la configuración de la base de datos en el archivo settings.py:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'django',
        'USER': 'djadmin',
        'PASSWORD': 'djadmin',
        'HOST': 'localhost',
        'PORT': '',
    }
}

Creamos la copia de seguridad de la aplicación en bravo:

sudo python manage.py dumpdata > /home/roberto/basedatos.json

y la restauramos en el VPS:

(django)$ python manage.py migrate
(django)$ python manage.py loaddata basedatos.json
Installed 57 object(s) from 1 fixture(s)

Finalmente generamos el contenido estático:

(django)$ python manage.py collectstatic

Configuración de nginx

Instalamos uwsgi:

pip install uwsgi

Podemos comprobar que funciona correctamente:

uwsgi --http :8080 --chdir /home/calcetines/django_tutorial --wsgi-file django_tutorial/wsgi.py --process 4 --threads 2 --master

Creamos el fichero de configuración de uwsgi en /home/calcetines/django/servidor.ini:

[uwsgi]
http = :8080
chdir = /home/calcetines/django_tutorial 
wsgi-file = django_tutorial/wsgi.py
processes = 4
threads = 2

Ahora crearemos la unidad de systemd para que se ejecute uwsgi como servicio en el fichero /etc/systemd/system/uwsgi-django.service:

[Unit]
Description=uwsgi-django
After=network.target

[Install]
WantedBy=multi-user.target

[Service]
User=www-data
Group=www-data
Restart=always

ExecStart=/home/calcetines/django/bin/uwsgi /home/calcetines/django/servidor.ini
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

WorkingDirectory=/home/calcetines/django_tutorial
Environment=PYTHONPATH='/home/calcetines/django_tutorial:/home/calcetines/django/lib/python3.9/site-packages'

PrivateTmp=true

activamos el servicio:

systemctl enable uwsgi-django.service
systemctl start uwsgi-django.service

Ahora configuramos nginx como proxy inverso añadiendo la siguiente configuración en el fichero /etc/nginx/sites-available/django:

server {
    listen          80;
    server_name     python.admichin.es;
    
    if ($host ~ ^[^.]+\.admichin\.es$) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

}

server {
    listen          443 ssl;
    server_name     python.admichin.es;
    access_log      /var/log/nginx/example.com_access.log combined;
    error_log       /var/log/nginx/example.com_error.log error;

        ssl_certificate /etc/letsencrypt/live/admichin.es-0001/fullchain.pem; # managed by Certbot
        ssl_certificate_key /etc/letsencrypt/live/admichin.es-0001/privkey.pem; # managed by Certbot

    location /static/ {
        root /home/calcetines/django_tutorial;
    }

    location / {
        proxy_pass         http://localhost:8080/;
        include proxy_params;
        proxy_redirect     off;

        proxy_set_header   X-Real-IP         $remote_addr;
        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
    }
}

Desactivamos el modo debug en el fichero settings.py:

DEBUG = False

Finalmente accedemos a la página web en python.admichin.es y comprobamos que funciona correctamente.

Tarea 3: Modificación de nuestra aplicación

En el entorno de desarrollo

Vamos a hacer las siguientes modificaciones:

Modificamos el fichero django_tutorial/polls/templates/polls/index.html para que aparezca nuestro nombre.
Modificamos la imagen de fondo que se ve la aplicación. Para hacerlo debemos modificar el fichero django_tutorial/polls/static/polls/css/style.css y cambiar la siguiente línea, estando la imagen en la carpeta django_tutorial/polls/static/polls/images:

    background: white url("images/gundam.jpg");

Ahora vamos a crear una nueva tabla en la base de datos para almacenar las categorías de las preguntas. Para ello sigue los siguientes pasos:

Se Añade un nuevo modelo al fichero django_tutorial/polls/models.py:

class Categoria(models.Model):	
    Abr = models.CharField(max_length=4)
    Nombre = models.CharField(max_length=50)

    def __str__(self):
        return self.Abr+" - "+self.Nombre

Se crea una nueva migración.

(django)$ sudo python manage.py makemigrations --name tabla_categoria

Migrations for 'polls':
  polls/migrations/0002_tabla_categoria.py
    - Create model Categoria

Se realiza la migración.

(django)$ sudo python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, polls, sessions
Running migrations:
  Applying polls.0002_tabla_categoria... OK

Se añade el nuevo modelo al sitio de administración de django modificando el fichero django_tutorial/polls/admin.py:

from .models import Choice, Question, Categoria

[...]

admin.site.register(Categoria)

Para que los cambios se trasladen al entorno de producción debemos realizar los siguientes pasos:

(django)$ sudo python manage.py
(django)$ sudo python manage.py dumpdata > basedatos2.json
(django)$ sudo python manage.py collectstatic # este no hace falta para el entorno de producción
(django)$ git push

En el entorno de producción

Se realiza la migración.

(django)$ git pull
(django)$ sudo python manage.py migrate
(django)$ sudo python manage.py loaddata basedatos2.json
(django)$ sudo python manage.py collectstatic

Podemos comprobar que se han producido los cambios:

Recolección centralizada de logs de sistema, mediante Journald

Sun, 15 Jan 2023 00:00:00 GMT

El escenario de OpenStack es el siguiente:

Enunciado

Implementa en tu escenario de trabajo de Openstack, un sistema de recolección de log mediante journald. Para ello debes, implementar un sistema de recolección de log mediante el paquete systemd-journal-remote, o similares.

Preparación

En cada instancia, voy a instalar el paquete systemd-journal-remote; en alfa, charlie y delta ejecuto el siguiente comando:

apt install systemd-journal-remote

en bravo, ejecuto el siguiente comando:

sudo dnf install systemd-journal-remote

Configuración

He elegido el servidor alfa como servidor de logs, por lo que en él, voy a configurar el servicio. No voy a usar https ni autenticación, por lo que en el fichero /lib/systemd/system/systemd-journal-remote.service voy a modificar la siguientes línea:

ExecStart=/lib/systemd/systemd-journal-remote --listen-http=-3 --output=/var/log/journal/remote/

Ahora inicio el servicio y lo habilito para que se inicie en el arranque:

sudo systemctl enable --now systemd-journal-remote.socket
sudo systemctl enable --now systemd-journal-remote.service

sudo systemctl status systemd-journal-remote.socket
sudo systemctl status systemd-journal-remote.service

Configuración de los clientes

Para ello, en cada uno crearé un usuario llamado systemd-journal-upload configurado de la siguiente manera:

en charlie y delta

sudo adduser --system --home /run/systemd --no-create-home --disabled-login --group systemd-journal-upload

en bravo

sudo adduser --system --home-dir /run/systemd --no-create-home --user-group systemd-journal-upload

Ahora modifico en el fichero /etc/systemd/journal-upload.conf la siguiente línea:

URL=http://alfa.roberto.gonzalonazareno.org:19532

Ahora reinicio el servicio en todas las máquinas:

sudo systemctl restart systemd-journal-upload.service

Comprobación

En el servidor alfa, voy a comprobar que se están recibiendo los logs de los clientes

Para ver los logs de los clientes, en el servidor alfa, ejecuto el siguiente comando (en este caso, el de delta):

sudo journalctl --file /var/log/journal/remote/remote-192.168.0.3.journal

En un ejemplo anterior: Ejemplo completo: Desplegando y accediendo a la aplicación Temperaturas habíamos desplegado una aplicación formada por dos microservicios que nos permitía visualizar las temperaturas de municipios.

Escenario DNS

Mon, 19 Dec 2022 00:00:00 GMT

El enunciado de la prácica se encuentra en el siguiente enlace

1. Configuración DNS de cada máquina

Para no tocar la configuración de los servidores DHCP de OpenStack, cambiamos manualmente la configuración de las máquinas Alfa, Bravo y Delta para que tengan como servidor DNS el servidor bind9 en Charlie, así como el dns del centro (Babuino). Para ello, editamos el fichero /etc/resolv.conf y añadimos las siguientes líneas:

nameserver 192.168.0.2
nameserver 192.168.202.2

Para hacer los cambios persistentes en debian/ubuntu, instalamos el paquete resolvconfy añadimos los dns al final del fichero /etc/resolvconf/resolv.conf.d/head. Para aplicar los cambios sin tener que reiniciar tenemos que ejecutar el comando resolvconf -u.

VISTAS

view interna {
    match-clients { 192.168.0.0/24; 127.0.0.1; };
    allow-recursion { any; };
        zone "roberto.gonzalonazareno.org"
        {
        type master;
        file "db.interna.roberto.gonzalonazareno.org";
        };
        zone "0.168.192.in-addr.arpa"
        {
        type master;
        file "db.0.168.192";
        };
        zone "16.172.in-addr.arpa"
        {
        type master;
        file "db.0.16.172";
        };
        include "/etc/bind/zones.rfc1918";
        include "/etc/bind/named.conf.default-zones";
    };

view dmz {
    match-clients { 172.16.0/16;};
    allow-recursion { any; };
        zone "roberto.gonzalonazareno.org"
        {
        type master;
        file "db.dmz.roberto.gonzalonazareno.org";
        };
        zone "16.172.in-addr.arpa"
        {
        type master;
        file "db.16.172";
        };
        include "/etc/bind/zones.rfc1918";
        include "/etc/bind/named.conf.default-zones";
    };

view externa {
    match-clients { 172.22.0.0/16; 172.29.0.0/16; 192.168.202.2; };
    allow-recursion { any; };
        zone "roberto.gonzalonazareno.org"
        {
        type master;
        file "db.externa.roberto.gonzalonazareno.org";
        };
        include "/etc/bind/zones.rfc1918";
        include "/etc/bind/named.conf.default-zones";
};

Definición de las zonas

INTERNA /var/cache/bind/db.interna.roberto.gonzalonazareno.org

$TTL    86400
@       IN      SOA     charlie.roberto.gonzalonazareno.org. root.roberto.gonzalonazareno.org. (
                            1           ; Serial
                        604800          ; Refresh
                        86400           ; Retry
                        2419200         ; Expire
                        86400 )         ; Negative Cache TTL
;
@	IN	NS		charlie.roberto.gonzalonazareno.org.
@	IN	MX	10	mail.roberto.gonzalonazareno.org.

$ORIGIN roberto.gonzalonazareno.org.

alfa        IN  A       192.168.0.1
bravo       IN  A       172.16.0.200
charlie     IN  A       192.168.0.2
delta       IN  A       192.168.0.3
www         IN  CNAME   bravo
bd          IN  CNAME   delta

INTERNA INVERSA /var/cache/bind/db.0.168.192

$TTL    86400
@       IN      SOA     charlie.roberto.gonzalonazareno.org. root.roberto.gonzalonazareno.org. (
                            1         ; Serial
                        604800         ; Refresh
                        86400         ; Retry
                        2419200         ; Expire
                        86400 )       ; Negative Cache TTL
;
@	IN	NS		charlie.roberto.gonzalonazareno.org.

$ORIGIN 0.168.192.in-addr.arpa.

1			IN	PTR		alfa.roberto.gonzalonazareno.org.
2            IN	PTR		charlie.roberto.gonzalonazareno.org.
3            IN	PTR		delta.roberto.gonzalonazareno.org.

INTERNA INVERSA /var/cache/bind/db.16.172

$TTL    86400
@       IN      SOA     charlie.roberto.gonzalonazareno.org. root.roberto.gonzalonazareno.org. (
                            1         ; Serial
                        604800         ; Refresh
                        86400         ; Retry
                        2419200         ; Expire
                        86400 )       ; Negative Cache TTL
;
@	IN	NS		charlie.roberto.gonzalonazareno.org.

$ORIGIN 16.172.in-addr.arpa.

1.0			IN	PTR		alfa.roberto.gonzalonazareno.org.
200.0            IN	PTR		bravo.roberto.gonzalonazareno.org.

DMZ /var/cache/bind/db.dmz.roberto.gonzalonazareno.org

$TTL    86400
@       IN      SOA     charlie.roberto.gonzalonazareno.org. root.roberto.gonzalonazareno.org. (
                            1           ; Serial
                        604800          ; Refresh
                        86400           ; Retry
                        2419200         ; Expire
                        86400 )         ; Negative Cache TTL
;
@	IN	NS		charlie.roberto.gonzalonazareno.org.

$ORIGIN roberto.gonzalonazareno.org.

alfa        IN  A       172.16.0.1
bravo       IN  A       172.16.0.200
charlie     IN  A       192.168.0.2
delta       IN  A       192.168.0.3
www         IN  CNAME   bravo
bd          IN  CNAME   delta

EXTERNA /var/cache/bind/db.externa.roberto.gonzalonazareno.org

$TTL    86400
@       IN      SOA     alfa.roberto.gonzalonazareno.org. root.roberto.gonzalonazareno.org. (
                            1           ; Serial
                        604800          ; Refresh
                        86400           ; Retry
                        2419200         ; Expire
                        86400 )         ; Negative Cache TTL
;
@	IN	NS		alfa.roberto.gonzalonazareno.org.

$ORIGIN roberto.gonzalonazareno.org.

alfa        IN  A       172.22.200.218
www         IN  CNAME   alfa

Configuración de los servidores web

<VirtualHost *:80>
    ServerName www.roberto.gonzalonazareno.org

    ServerAdmin webmaster@localhost

    DocumentRoot /var/www/html

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined

    <FilesMatch "\.php$">
        SetHandler "proxy:unix:/run/php/php7.4-fpm.sock|fcgi://127.0.0.1/" 
        SetHandler "proxy:fcgi://127.0.0.1:9000" 
    </FilesMatch>

</VirtualHost>

Resolución de problemas de tablas mutantes

Mon, 19 Dec 2022 00:00:00 GMT

El enunciado a resolver y que contiene una tabla mutante es el siguiente:

6 - Realiza los módulos de programación necesarios para evitar que un catador puntue más de tres aspectos de una misma versión de un experimento.

En este caso, el trigger principal sería sobre la tabla puntuaciones, y dentro, para comprobar que se cumple la condición de que un catador no puntúa más de 3 aspectos, se tendría que hacer una consulta a la misma tabla puntuaciones, que en ese caso estaría mutando. Para resolver el problema vamos a realizar los siguientes pasos:

Leer bien los requisitos del problema e identificar la información de la tabla que debo guardar en variables persistentes.
Crear el paquete declarando los tipos de datos y las variables necesarias para guardar dicha información.
Hacer un trigger before por sentencia que rellene dichas variables consultando la tabla mutante.
Hacer un trigger before por fila que compruebe si el registro que se está manejando cumple la condición especificada consultando las variables persistentes.

Leer bien los requisitos del problema e identificar la información de la tabla que debo guardar en variables persistentes

El contenido de la tabla de puntuaciones es el siguiente:

En este caso, tendríamos que almacenar en variables persistentes los datos de la consulta, que en este caso son los siguientes campos:

NIFCatador
CodigoAspecto
CodigoExperimento
CodigoVersion

Crear el paquete declarando los tipos de datos y las variables necesarias para guardar dicha información

CREATE OR REPLACE PACKAGE ControlPuntuaciones
AS
TYPE tRegistroTablaPuntuaciones IS RECORD --defino el tipo de datos registro
(
NIFCatador Puntuaciones.NIFCatador%TYPE,
CodigoAspecto Puntuaciones.CodigoAspecto%TYPE,
CodigoExperimento Puntuaciones.CodigoExperimento%TYPE,
CodigoVersion Puntuaciones.CodigoVersion%TYPE
);

TYPE tTablasPuntuaciones IS TABLE OF tRegistroTablaPuntuaciones -- defino el tipo de datos tabla
INDEX BY BINARY_INTEGER;
PuntuacionesCatador tTablasPuntuaciones;
-- declaro una variable del tipo tabla antes creado
END ControlPuntuaciones;
/

Hacer un trigger before por sentencia que rellene dichas variables consultando la tabla mutante

CREATE OR REPLACE TRIGGER RELLENARPUNTUACIONES
BEFORE INSERT OR UPDATE ON Puntuaciones
FOR EACH ROW
DECLARE
CURSOR c_puntuaciones IS SELECT NIFCatador,CodigoAspecto,CodigoExperimento,CodigoVersion
FROM Puntuaciones;
INDICE NUMBER:=0;
indice_u number;
BEGIN

-- vacio el contenido de la tabla
ControlPuntuaciones.PuntuacionesCatador.DELETE;
-- relleno la tabla de puntuaciones los datos que me interesan
FOR v_puntuacion IN c_puntuaciones LOOP
ControlPuntuaciones.PuntuacionesCatador(INDICE).NIFCatador := v_puntuacion.NIFCatador;
ControlPuntuaciones.PuntuacionesCatador(INDICE).CodigoAspecto := v_puntuacion.CodigoAspecto;
ControlPuntuaciones.PuntuacionesCatador(INDICE).CodigoExperimento := v_puntuacion.CodigoExperimento;
ControlPuntuaciones.PuntuacionesCatador(INDICE).CodigoVersion := v_puntuacion.CodigoVersion;
INDICE := INDICE + 1;
END LOOP;
if inserting then
indice_u := ControlPuntuaciones.PuntuacionesCatador.LAST + 1;
ControlPuntuaciones.PuntuacionesCatador(indice_u).NIFCatador := :NEW.NIFCatador;
ControlPuntuaciones.PuntuacionesCatador(indice_u).CodigoAspecto := :NEW.CodigoAspecto;
ControlPuntuaciones.PuntuacionesCatador(indice_u).CodigoExperimento := :NEW.CodigoExperimento;
ControlPuntuaciones.PuntuacionesCatador(indice_u).CodigoVersion := :NEW.CodigoVersion;
end if;

END RELLENARPUNTUACIONES;
/

Hacer un trigger before por fila que compruebe si el registro que se está manejando cumple la condición especificada consultando las variables persistentes

CREATE OR REPLACE TRIGGER ControlarPuntuaciones
BEFORE INSERT OR UPDATE ON Puntuaciones
FOR EACH ROW
DECLARE
BEGIN
-- compruebo que el catador no haya puntuado más de 3 aspectos
IF (NumeroPuntuacionesCatador(:NEW.NIFCatador,:NEW.CodigoExperimento,:NEW.CodigoVersion) > 3) THEN
RAISE_APPLICATION_ERROR(-20001,'El catador no puede puntuar mas de 3 aspectos');
end if;
END;
/

Voy a crear una funcion para comprobar el numero de puntuaciones que tiene un catador en una versión de un experimento:

CREATE OR REPLACE FUNCTION NumeroPuntuacionesCatador
( p_NIFCatador Puntuaciones.NIFCatador%TYPE, p_CodigoExperimento Puntuaciones.CodigoExperimento%TYPE, p_CodigoVersion Puntuaciones.CodigoVersion%TYPE)
RETURN NUMBER
IS
    v_NumeroPuntuaciones NUMBER:= 1;
    v_cantidad NUMBER;
BEGIN
    for i in ControlPuntuaciones.PuntuacionesCatador.FIRST..ControlPuntuaciones.PuntuacionesCatador.LAST
    LOOP
        if (ControlPuntuaciones.PuntuacionesCatador(i).NIFCatador = p_NIFCatador) and (ControlPuntuaciones.PuntuacionesCatador(i).CodigoExperimento = p_CodigoExperimento) and (ControlPuntuaciones.PuntuacionesCatador(i).CodigoVersion = p_CodigoVersion) then
            v_NumeroPuntuaciones := v_NumeroPuntuaciones + 1;
        end if;
    END LOOP;
    return v_NumeroPuntuaciones;
end;
/

--- prueba

create or replace procedure prueba
is
numero number;
begin
numero:=NumeroPuntuacionesCatador('14425879A','A0003-A','0.0.2');
dbms_output.put_line(numero);
end;
/
insert into puntuaciones values('14425879A','0004','A0003-A','0.0.2',7.5);


create or replace procedure imprimirtabla
is
begin
    for i in ControlPuntuaciones.PuntuacionesCatador.FIRST..ControlPuntuaciones.PuntuacionesCatador.LAST
    LOOP
        dbms_output.put_line('Registro numero '|| i);
        dbms_output.put_line('NIFCatador: '|| ControlPuntuaciones.PuntuacionesCatador(i).NIFCatador);
        dbms_output.put_line('CodigoAspecto: '|| ControlPuntuaciones.PuntuacionesCatador(i).CodigoAspecto);
        dbms_output.put_line('CodigoExperimento: '|| ControlPuntuaciones.PuntuacionesCatador(i).CodigoExperimento);
        dbms_output.put_line('CodigoVersion: '|| ControlPuntuaciones.PuntuacionesCatador(i).CodigoVersion);


    end loop;
end;
/

insert into puntuaciones values('14425879A','0004','A0003-A','0.0.2',7.5);
insert into puntuaciones values('14425879A','0005','A0003-A','0.0.2',7.5);
insert into puntuaciones values('14425879A','0006','A0003-A','0.0.2',7.5);
insert into puntuaciones values('14425879A','0007','A0003-A','0.0.2',7.5);
select * from puntuaciones where nifcatador='14425879A' and codigoexperimento='A0003-A' and codigoversion='0.0.2';
insert into puntuaciones values('14425879A','0005','A0003-A','0.0.1',7.5);

Montaje NFS mediante systemd

Thu, 15 Dec 2022 00:00:00 GMT

En una instancia del cloud, basada en la distribución de tu elección, anexa un volumen de 2GB. En dicha instancia deberás configurar el servicio nfs de exportación y en el volumen un punto de montaje de la exportación mediante systemd.

Escenario

El escenario se compone de dos máquinas, alfa, con debian 11 y que será el servidor nfs; y bravo, con rocky linux 8 y que será el cliente nfs.

Servidor NFS

Instalamos los paquetes necesarios para el servicio nfs:

apt install nfs-kernel-server nfs-common

Creamos el fichero /etc/systemd/system/mnt-carpeta.mount con el siguiente contenido. El nombre del fichero, tiene que ser el mismo que el del punto de montaje en el que vamos a montar el dispositivo, además de sustituyendo las "/" por "-" (menos la primera):

[Unit]
Description=Montaje de disco para compartir

[Mount]
What= /dev/vdb
Where= /mnt/carpeta/
Type=ext4
Options=defaults

[Install]
WantedBy=multi-user.target

Activamos el servicio:

systemctl enable mnt-carpeta.mount
systemctl start mnt-carpeta.mount

Si no funciona el montaje de la unidad, podemos comprobar os errores con journalctl -xe

Tras el montaje podemos comprobar que el disco se ha montado correctamente:

Finalmente, añadimos la siguiente línea al fichero /etc/exports:

/mnt/carpeta 172.16.0.0/16(rw,no_all_squash,no_subtree_check)

Y reiniciamos el servicio:

systemctl restart nfs-server

Cliente NFS

Instalamos los paquetes necesarios para el servicio nfs:

dnf install nfs-utils

Podemos ver los dispositivos de bloques que se están compartiendo por nfs (la ip del servidor nfs es 172.16.0.1):

showmount -e 172.16.0.1

Creamos el fichero /etc/systemd/system/mnt-carpetaNFS.mount con el siguiente contenido:

[Unit]
Description=Montaje del disco compartido por red usando NFS

[Mount]
What=172.16.0.1:/mnt/carpeta
Where=/mnt/carpetaNFS
Type=nfs
Options=defaults

[Install]
WantedBy=multi-user.target

Activamos el servicio:

systemctl enable mnt-carpetaNFS.mount
systemctl start mnt-carpetaNFS.mount

Podemos comprobar que el disco se ha montado correctamente:

Comprobación

Comprobamos que el dispositivo de bloques se está compartiendo por nfs:

Compilación Kernel

Wed, 07 Dec 2022 00:00:00 GMT

Compilación de un Kernel linux a medida

Al ser linux un kérnel libre, es posible descargar el código fuente, configurarlo y comprimirlo. Además, esta tarea a priori compleja, es más sencilla de lo que parece gracias a las herramientas disponibles. En esta tarea debes tratar de compilar un kérnel completamente funcional que reconozca todo el hardware básico de tu equipo y que sea a la vez lo más pequeño posible, es decir que incluya un vmlinuz lo más pequeño posible y que incorpore sólo los módulos imprescindibles. Para ello utiliza el método explicado en clase y entrega finalmente el fichero deb con el kérnel compilado por ti. El hardware básico incluye como mínimo el teclado, la interfaz de red y la consola gráfica (texto).

Descarga

En este caso vamos a descargar el último kernel de linux de la página oficial:

wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.0.7.tar.xz
tar xf linux-6.0.7.tar.xz
cd linux-6.0.7

Compilación del kernel

Para configurar los módulos que tenemos cargados actualmente en el sistema tenemos que introducir losa siguientes comandos:

make oldconfig
make localyesconfig

Con lo siguiente podemos comprobar el número de módulos estáticos y dinámicos que tenemos actualmente:

egrep '=y' .config | wc -l
egrep '=m' .config | wc -l

Para compilar el kernel, tenemos que ejecutar el siguiente comando, que aprovecha el número de núcleos que tenemos para reducir al máximo el tiempo de compilación:

time make -j $(nproc) bindeb-pkg

Reducir el kernel

Para reducir el tamaño del kernel tenemos que desactivar módulos. Éstos se desactivan ejecutando el siguiente comando:

make clean
make xconfig

que abre una interfaz gráfica en la que podemos seleccionar los módulos quq queremos activar o desactivar:

Instalación/migración de aplicaciones web PHP

Wed, 07 Dec 2022 00:00:00 GMT

Escenario

Vamos a hacer un escenario de vagrant utilizando el siguiente Vagrantfile:

Vagrant.configure("2") do |config|

config.vm.define :web do |web|
    web.vm.box = "debian/bullseye64"
    web.vm.hostname = "servidor-web-roberto"
    web.vm.synced_folder ".", "/vagrant", disabled: true
    web.vm.network :public_network,
      :dev => "bridge0",
      :mode => "bridge",
      :type => "bridge",
      use_dhcp_assigned_default_route: true
    web.vm.network :private_network,
      :libvirt__network_name => "net1",
      :libvirt__dhcp_enabled => false,
      :ip => "10.0.0.1",
      :libvirt__forward_mode => "veryisolated"
  end
  config.vm.define :bd do |bd|
    bd.vm.box = "debian/bullseye64"
    bd.vm.hostname = "servidor-bd-roberto"
    bd.vm.synced_folder ".", "/vagrant", disabled: true
    bd.vm.network :private_network,
      :libvirt__network_name => "net1",
      :libvirt__dhcp_enabled => false,
      :ip => "10.0.0.2",
      :libvirt__forward_mode => "veryisolated"
  end
end

Configuración de resolución estática

Vamos a configurar la resolución estática de las páginas utilizando la IP pública de la máquina web:

Instalación de un CMS PHP en mi servidor local

En este caso el CMS que vamos a instalar es Media Wiki. Ahora vamos a configurar el servidor y la base de datos.

En el servidor web instalamos apache con php:

apt update
apt install apache2 libapache2-mod-php php php-mysql

Configuración del VirtualHost

Vamos a instalar el cms en /var/www/mediawiki, por lo configuramos el vhost en el fichero etc/apache2/sites-available/mediawiki.conf:

<VirtualHost *:80>
        ServerName www.roberto.org

        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/mediawiki

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

# vim: syntax=apache ts=4 sw=4 sts=4 sr noet

Ahora activamos el VirtualHost

a2ensite mediawiki
systemctl reload apache2

Configuración de la base de datos

En el servidor que va a tener la base de datos, instalamos mariadb:

apt update
apt install mariadb-server
mariadb -u root

Dentro vamos a crear una base de datos para el CMS y un usuario con permisos:

GRANT ALL PRIVILEGES ON *.* TO 'remoto'@'%'
IDENTIFIED BY 'remoto' WITH GRANT OPTION;

create database mediawiki;

Para configurar el acceso remoto, tenemos que modificar en fichero /etc/mysql/mariadb.conf.d/50-server.cnf, la siguiente línea:

bind-address            = 0.0.0.0

Y reiniciamos el servicio.

Ahora desde el cliente creamos el siguiente usuario:

GRANT ALL PRIVILEGES ON *.* TO 'remoto'@'10.0.0.2' IDENTIFIED BY 'remoto' WITH GRANT OPTION;

y podemos conectarnos a la base de datos remota con el siguiente comando:

mysql -u remoto -h 10.0.0.2 --password=remoto

Instalación MediaWiki

Para instalar media wiki, tenemos que descargar la última versión de la página oficial:

wget https://releases.wikimedia.org/mediawiki/1.38/mediawiki-1.38.4.tar.gz
tar -xf mediawiki-1.38.4.tar.gz
cp -r mediawiki-1.38.4/* /var/www/mediawiki/
chown -R www-data:www-data /var/www/mediawiki/

Antes de iniciar la instalación tenemos que instalar los siguientes paquetes:

apt install php-mbstring php-xml php-intl -y
systemctl restart apache2.service

Ahora seguimos la instalación normalmente, pero en la configuración de la base de datos es importante especificar la IP:

Una vez finalizada la configuración inicial, se descarga el fichero LocalSettings.php:

Tenemos que moverlo al Document Root de MediaWiki:

chown www-data:www-data LocalSettings.php
mv LocalSettings.php /var/www/mediawiki/

Una vez realizada la configuración, accediendo a www.roberto.org aparece la wiki:

Instalación de un módulo

Tras configurar el tema, vamos a instalar un módulo: SimpleCalendar:

wget https://extdist.wmflabs.org/dist/extensions/SimpleCalendar-REL1_38-b7a2f05.tar.gz
tar -xf SimpleCalendar-REL1_38-b7a2f05.tar.gz
mv SimpleCalendar /var/www/mediawiki/extensions/

Ahora añadimos la siguiente línea al final de LocalSettings.php:

echo "wfLoadExtension( 'SimpleCalendar' );" >> /var/www/mediawiki/LocalSettings.php

Una vez hecho, podemos comprobar que está correctamente instalado accediendo a http://www.roberto.org/index.php/Especial:Versión

Ya instalado, podemos añadir calendarios a las páginas de la wiki con el siguiente bloque:

{{#calendar: year=2022 | month=nov | title="calendario" }}

Y quedaría de la siguiente forma:

Instalación del CMS PHP NextCloud

Primero descargamos la última versión y lo movemos al directorio de apache:

wget https://download.nextcloud.com/server/releases/latest.zip
unzip latest.zip
cp -r nextcloud/ /var/www/
chown -R www-data:www-data /var/www/nextcloud/

Ahora configuramos el vhost en el fichero etc/apache2/sites-available/nextcloud.conf:

<VirtualHost *:80>
        ServerName www.cloud.roberto.org        
        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/nextcloud        
        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined     
</VirtualHost>

a2ensite nextcloud.conf
systemctl reload apache2.service

E instalamos los módulos de php necesarios:

  apt install php-zip php-gd php-curl -y
systemctl reload apache2.service

Ahora en la máquina con la base de datos creamos la base de datos para nextcloud:

create database nextcloud;

Tras este paso, podemos acceder a cloud.roberto.org para iniciar la instalación, es importante que en la base de datos especifiquemos la ip y el puerto de la máquina con la base de datos:

Una vez finalizada la instalación, ya podremos utilizar nextcloud:

DNS del dominio

Para configurar el dns tenemos que mirar la dirección en la configuración del VPS:

y añadir un registro CNAME en la dirección www.admichin.es que lleve a esa dirección:

Configuración del servidor LEMP

Para instalar el servidor lemp tenemos que instalar los siguientes paquetes:

apt install 
apt install nginx php php-mysql mariadb-server -y

Ahora, en la máquina con la base de datos, creamos un fichero con la copia de seguridad y lo enviamos a la vps:

mysqldump -u remoto -p -x -A > dbs.sql
scp dbs.sql calcetines@nodriza.admichin.es:/home/calcetines

Ahora creamos en la base de datos un usuario con permisos y restauramos las bases de datos:

GRANT ALL PRIVILEGES ON *.* TO 'admin'@localhost IDENTIFIED BY 'contraseña' WITH GRANT OPTION;

mysql --user admin --password < dbs.sql

Migración de las aplicaciones

Para migrar las aplicaciones, tenemos que moverlas al servidor. En este caso utilizaré rsync ya que permite reanudar la transmisión si se interrumpe, además de ser más rápido que scp:

rsync -avP /var/www/mediawiki/ calcetines@nodriza.admichin.es:/home/calcetines/mediawiki
rsync -avP /var/www/nextcloud/ calcetines@nodriza.admichin.es:/home/calcetines/nextcloud

Una vez finalizado, en este caso vamos a utilizar un solo virtualhost, por lo que los directorios de ambas aplicaciones deben estar en /var/www/html/nombreaplicacion:

upstream php-handler {
    #server 127.0.0.1:9000;
    server unix:/var/run/php/php7.4-fpm.sock;
}

# Set the `immutable` cache control options only for assets with a cache busting `v` argument
map $arg_v $asset_immutable {
    "" "";
    default "immutable";
}

server {
    listen 80;
    listen [::]:80;
    server_name www.admichin.es;

    # Prevent nginx HTTP Server Detection
    #server_tokens off;
    rewrite ^/$ /portal;

    # Path to the root of the domain
    root /var/www/html;

    location = /robots.txt {
        allow all;
        log_not_found off;
        access_log off;
    }

    location ^~ /.well-known {
        # The rules in this block are an adaptation of the rules
        # in the cloud `.htaccess` that concern `/.well-known`.

        location = /.well-known/carddav { return 301 /cloud/remote.php/dav/; }
        location = /.well-known/caldav  { return 301 /cloud/remote.php/dav/; }

        location /.well-known/acme-challenge    { try_files $uri $uri/ =404; }
        location /.well-known/pki-validation    { try_files $uri $uri/ =404; }

        # Let cloud's API for `/.well-known` URIs handle all other
        # requests by passing them to the front-end controller.
        return 301 /cloud/index.php$request_uri;
    }
    location ^~ /portal {
        # set max upload size and increase upload timeout:
        client_max_body_size 512M;
        client_body_timeout 300s;
        fastcgi_buffers 64 4K;

        gzip on;
        gzip_vary on;
        gzip_comp_level 4;
        gzip_min_length 256;
        gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
        gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/wasm application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;


        client_body_buffer_size 512k;

        # HTTP response headers borrowed from cloud `.htaccess`
        add_header Referrer-Policy                      "no-referrer"   always;
        add_header X-Content-Type-Options               "nosniff"       always;
        add_header X-Download-Options                   "noopen"        always;
        add_header X-Frame-Options                      "SAMEORIGIN"    always;
        add_header X-Permitted-Cross-Domain-Policies    "none"          always;
        add_header X-Robots-Tag                         "none"          always;
        add_header X-XSS-Protection                     "1; mode=block" always;

        fastcgi_hide_header X-Powered-By;

        index index.php index.html /portal/index.php$request_uri;

        location ~ \.php(?:$|/) {

            fastcgi_split_path_info ^(.+?\.php)(/.*)$;
            set $path_info $fastcgi_path_info;

            try_files $fastcgi_script_name =404;

            include fastcgi_params;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_param PATH_INFO $path_info;

            fastcgi_param modHeadersAvailable true;         # Avoid sending the security headers twice
            fastcgi_param front_controller_active true;     # Enable pretty urls
            fastcgi_pass php-handler;

            fastcgi_intercept_errors on;
            fastcgi_request_buffering off;

            fastcgi_max_temp_file_size 0;
        }

        location /portal {
            try_files $uri $uri/ /portal/index.php$request_uri;
        }
    }
    location ~ /\.ht {
          deny all;
         }

    location ^~ /cloud {
        # set max upload size and increase upload timeout:
        client_max_body_size 512M;
        client_body_timeout 300s;
        fastcgi_buffers 64 4K;
        # Enable gzip but do not remove ETag headers
        gzip on;
        gzip_vary on;
        gzip_comp_level 4;
        gzip_min_length 256;
        gzip_proxied expired no-cache no-store private no_last_modified no_etag auth;
        gzip_types application/atom+xml application/javascript application/json application/ld+json application/manifest+json application/rss+xml application/vnd.geo+json application/vnd.ms-fontobject application/wasm application/x-font-ttf application/x-web-app-manifest+json application/xhtml+xml application/xml font/opentype image/bmp image/svg+xml image/x-icon text/cache-manifest text/css text/plain text/vcard text/vnd.rim.location.xloc text/vtt text/x-component text/x-cross-domain-policy;
        # HTTP response headers borrowed from cloud `.htaccess`
        add_header Referrer-Policy                      "no-referrer"   always;
        add_header X-Content-Type-Options               "nosniff"       always;
        add_header X-Download-Options                   "noopen"        always;
        add_header X-Frame-Options                      "SAMEORIGIN"    always;
        add_header X-Permitted-Cross-Domain-Policies    "none"          always;
        add_header X-Robots-Tag                         "none"          always;
        add_header X-XSS-Protection                     "1; mode=block" always;

        # Remove X-Powered-By, which is an information leak
        fastcgi_hide_header X-Powered-By;
        index index.php index.html /cloud/index.php$request_uri;

        # Rule borrowed from `.htaccess` to handle Microsoft DAV clients
        location = /cloud {
            if ( $http_user_agent ~ ^DavClnt ) {
                return 302 /cloud/remote.php/webdav/$is_args$args;
            }
        }

        # Rules borrowed from `.htaccess` to hide certain paths from clients
        location ~ ^/cloud/(?:build|tests|config|lib|3rdparty|templates|data)(?:$|/)    { return 404; }
        location ~ ^/cloud/(?:\.|autotest|occ|issue|indie|db_|console)                  { return 404; }
        location ~ \.php(?:$|/) {
            # Required for legacy support
            rewrite ^/cloud/(?!index|remote|public|cron|core\/ajax\/update|status|ocs\/v[12]|updater\/.+|oc[ms]-provider\/.+|.+\/richdocumentscode\/proxy) /cloud/index.php$request_uri;

            fastcgi_split_path_info ^(.+?\.php)(/.*)$;
            set $path_info $fastcgi_path_info;

            try_files $fastcgi_script_name =404;

            include fastcgi_params;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            fastcgi_param PATH_INFO $path_info;
           # fastcgi_param HTTPS on;

            fastcgi_param modHeadersAvailable true;         # Avoid sending the security headers twice
            fastcgi_param front_controller_active true;     # Enable pretty urls
            fastcgi_pass php-handler;

            fastcgi_intercept_errors on;
            fastcgi_request_buffering off;

            fastcgi_max_temp_file_size 0;
        }
        location ~ \.(?:css|js|svg|gif|png|jpg|ico|wasm|tflite|map)$ {
            try_files $uri /cloud/index.php$request_uri;
            add_header Cache-Control "public, max-age=15778463, $asset_immutable";
            access_log off;     # Optional: Don't log access to assets

            location ~ \.wasm$ {
                default_type application/wasm;
            }
        }
        location ~ \.woff2?$ {
            try_files $uri /cloud/index.php$request_uri;
            expires 7d;         # Cache-Control policy borrowed from `.htaccess`
            access_log off;     # Optional: Don't log access to assets
        }
        # Rule borrowed from `.htaccess`
        location /cloud/remote {
            return 301 /cloud/remote.php$request_uri;
        }
        location /cloud {
            try_files $uri $uri/ /cloud/index.php$request_uri;
        }
    }
}

MediaWiki

para migrar la aplicación de mediawiki tenemos que realizar los siguientes pasos:

Primero tenemos que transferir los ficheros que se encuentren en el document root de mediawiki a la vps, en este caso con rsync:

rsync -avP /var/www/mediawiki/ calcetines@nodriza.admichin.es:/home/calcetines/mediawiki

dentro de la vps lo movemos a su nueva ubicación:

mv mediawiki /var/www/html/portal

El último paso, es configurar el fichero LocalSettings.php (he quitado los comentarios para que sea menos largo):

<?php
if ( !defined( 'MEDIAWIKI' ) ) { exit;
}
$wgSitename = "adMICHIn.es"; $wgMetaNamespace = "AdMICHIn.es";
$wgScriptPath = "/portal";
$wgServer = "http://www.admichin.es";
$wgResourceBasePath = $wgScriptPath;
$wgLogos = [ '1x' => "https://i.imgur.com/KqnlgCE.png",
	
	
	'icon' => "https://i.imgur.com/KqnlgCE.png", ];
$wgEnableEmail = true; $wgEnableUserEmail = true; # UPO $wgEmergencyContact = "apache@������.invalid"; $wgPasswordSender = 
"apache@������.invalid"; $wgEnotifUserTalk = false; # UPO $wgEnotifWatchlist = false; # UPO $wgEmailAuthentication = true;
$wgDBtype = "mysql"; $wgDBserver = "localhost"; $wgDBname = "mediawiki"; $wgDBuser = "admin"; $wgDBpassword = 
"contraseña";
$wgDBprefix = "";
$wgDBTableOptions = "ENGINE=InnoDB, DEFAULT CHARSET=binary";
$wgSharedTables[] = "actor";
$wgMainCacheType = CACHE_NONE; $wgMemCachedServers = [];
$wgEnableUploads = false;
$wgUseInstantCommons = false;
$wgPingback = true;
$wgLanguageCode = "es";
$wgLocaltimezone = "UTC";
$wgSecretKey = "61c7675d604b7bd8b0b434dd7c53d6470ff8797636136e4ef7ade0e08cdaba14";
$wgAuthenticationTokenVersion = "1";
$wgUpgradeKey = "696787eac8f24d0f";
$wgRightsPage = ""; # Set to the title of a wiki page that describes your license/copyright $wgRightsUrl = ""; $wgRightsText = 
""; $wgRightsIcon = "";
$wgDiff3 = "/usr/bin/diff3";
$wgDefaultSkin = "MonoBook";
wfLoadSkin( 'MinervaNeue' ); wfLoadSkin( 'MonoBook' ); wfLoadSkin( 'Timeless' ); wfLoadSkin( 'Vector' );
wfLoadExtension( 'SimpleCalendar' );
$wgUsePathInfo = TRUE;

Tras eso mediaWiki estaría totalmente configurado y podremos acceder con: http://www.admichin.es

NextCloud

Para migrar nextcloud, el método es diferente. Siguiendo guía oficial hay que seguir los siguientes pasos:

En la vps, tenemos que instalar los requisitos previos de nextcloud

pt install php-zip php-gd php-curl -y

En la máquina original, hay que activar el modo mantenimiento del Nextcloud (desde el document root de nextcloud) y apagar el servidor tras 6-7 minutos:

sudo -u www-data php occ maintenance:mode --on
systemctl stop apache2

Cuando termine copiamos los ficheros de nextcloud a la vps:

rsync -avP /var/www/nextcloud/ calcetines@nodriza.admichin.es:/home/calcetines/nextcloud

Dentro de la vps lo movemos a su nueva ubicación:

mv nextcloud /var/www/html/cloud

en el fichero config.php tenemos que adaptar las opciones:

<?php
$CONFIG = array (
  'instanceid' => 'oct5tjcnoj2h',
  'passwordsalt' => 'uz7Kh0ZsihYsbbhIhL/HojMYSVc20y',
  'secret' => 'NxO/97NF1AoG+oCMrY3ryaefvSGO6SHczYjoc5x8NvsLZ1ma',
  'trusted_domains' => 
  array (
    0 => 'www.admichin.es',
  ),
  'datadirectory' => '/var/www/html/cloud/data',
  'dbtype' => 'mysql',
  'version' => '25.0.1.1',
  'overwrite.cli.url' => 'http://www.admichin.es/cloud',
  'dbname' => 'nextcloud',
  'dbhost' => 'localhost',
  'dbport' => '',
  'dbtableprefix' => 'oc_',
  'mysql.utf8mb4' => true,
  'dbuser' => 'oc_roberto',
  'dbpassword' => '}QR947P6^,vV%K$ATu]$W~%)AUhj6X',
  'installed' => true,
  'maintenance' => true,
);

Ahora, teniendo en cuenta que el serverblock de nginx está configurado, comprobamos que al acceder a http://www.admichin.es/cloud aparece el modo mantenimiento.
Si aparecece la misma imagen que en el caso anterior, entonces podemos cambiar el valor de configuración de mainteinance a false, y recargamos la página:

Práctica PL/SQL individual

Wed, 07 Dec 2022 00:00:00 GMT

Hacer un procedimiento que muestre el nombre y el salario del empleado cuyo código es 7782

CREATE OR REPLACE PROCEDURE mostrarnombresalario
is
    v_nombre emp.ename%type;
    v_salario emp.sal%type;
begin
    select ename,sal into v_nombre,v_salario from emp where empno=7782;
    dbms_output.put_line('El nombre del empleado es ' || v_nombre || ' y su salario es: ' || v_salario);
end;
/

Hacer un procedimiento que reciba como parámetro un código de empleado y devuelva su nombre

CREATE OR REPLACE PROCEDURE mostrarnombresalario2 (p_empno emp.empno%TYPE)
is
    v_nombre emp.ename%type;
    v_salario emp.sal%type;
begin
    select ename,sal into v_nombre,v_salario from emp where empno=p_empno;
    dbms_output.put_line('El nombre del empleado es ' || v_nombre || ' y su salario es: ' || v_salario);
end;
/

Hacer un procedimiento que devuelva los nombres de los tres empleados más antiguos

CREATE OR REPLACE PROCEDURE topantiguos
is
    cursor c_top is
        select ename
        from emp
        order by hiredate asc
        fetch first 3 rows only;
begin
    dbms_output.put_line('Los 3 empleados mas antiguos son: ');
    for v_empleado in c_top loop
        dbms_output.put_line(v_empleado.ename);
    end loop;
end;
/

Hacer un procedimiento que reciba el nombre de un tablespace y muestre los nombres de los usuarios que lo tienen como tablespace por defecto (Vista DBA_USERS)

CREATE OR REPLACE PROCEDURE verusuarios (p_tablespace dba_users.default_tablespace%type)
is
    cursor c_usuarios is
        SELECT username
        from dba_users
        where default_tablespace=p_tablespace;
begin
    dbms_output.put_line('El tablespace ' || p_tablespace || ' es el predeterminado de los siguientes usuarios:');
    for v_usuario in c_usuarios loop
        dbms_output.put_line(v_usuario.username);
    end loop;
end;
/

Modificar el procedimiento anterior para que haga lo mismo pero devolviendo el número de usuarios que tienen ese tablespace como tablespace por defecto. Nota: Hay que convertir el procedimiento en función

CREATE OR REPLACE function f_numusuarios (p_tablespace dba_users.default_tablespace%type)
return number
is
    v_num number;
begin
    select count(username) into v_num from dba_users where default_tablespace=p_tablespace;
    return v_num;
end;
/

Hacer un procedimiento llamado mostrar_usuarios_por_tablespace que muestre por pantalla un listado de los tablespaces existentes con la lista de usuarios de cada uno y el número de los mismos, así: (Vistas DBA_TABLESPACES y DBA_USERS)

Tablespace xxxx:

	Usr1
	Usr2
	...

Total Usuarios Tablespace xxxx: n1

Tablespace yyyy:

	Usr1
	Usr2
	...

Total Usuarios Tablespace yyyy: n2
....
Total Usuarios BD: nn

He modificado el procedimiento del ejercicio 4:

CREATE OR REPLACE PROCEDURE verusuarios (p_tablespace dba_users.default_tablespace%type)
is
    cursor c_usuarios is
        SELECT username
        from dba_users
        where default_tablespace=p_tablespace;
begin
    for v_usuario in c_usuarios loop
        dbms_output.put_line(CHR(9)|| v_usuario.username);
    end loop;
end;
/

Y el procedimiento nuevo es:

CREATE OR REPLACE PROCEDURE mostrar_usuarios_por_tablespace
is
    cursor c_tablespaces is
        SELECT tablespace_name
        from dba_tablespaces;
    v_total_usuario number;
    v_total number:=0;
begin
    for v_tablespace in c_tablespaces loop
        dbms_output.put_line('Tablespace ' || v_tablespace.tablespace_name);
        verusuarios(v_tablespace.tablespace_name);
        v_total_usuario:=f_numusuarios(v_tablespace.tablespace_name);
        v_total:=v_total+v_total_usuario;
        dbms_output.put_line('Total Usuarios tablespace ' || v_tablespace.tablespace_name || ': ' || v_total_usuario);
    end loop;
    dbms_output.put_line('Total Usuarios BD : ' || v_total);
end;
/

[...]

Hacer un procedimiento llamado mostrar_codigo_fuente que reciba el nombre de otro procedimiento y muestre su código fuente. (DBA_SOURCE)

CREATE OR REPLACE PROCEDURE mostrar_codigo_fuente (p_nombre dba_source.name%type)
is
    cursor c_codigo is
        SELECT text
        from dba_source
        where name=p_nombre;
begin
    for v_codigo in c_codigo loop
        dbms_output.put_line(v_codigo.text);
    end loop;
end;
/

Hacer un procedimiento llamado mostrar_privilegios_usuario que reciba el nombre de un usuario y muestre sus privilegios de sistema y sus privilegios sobre objetos. (DBA_SYS_PRIVS y DBA_TAB_PRIVS)

CREATE OR REPLACE PROCEDURE mostrar_privilegios_usuario (p_nombre dba_source.name%type)
is
    cursor c_sistema is
        SELECT privilege
        from dba_sys_privs
        where grantee=p_nombre
        and ADMIN_OPTION='YES'
        OR INHERITED='YES';
    cursor c_objetos is
        SELECT privilege,table_name
        from dba_tab_privs
        where grantee=p_nombre;
begin
    dbms_output.put_line('Privilegios del usuario '|| p_nombre || ' de sistema');
    for v_sistema in c_sistema loop
        dbms_output.put_line(CHR(9)||v_sistema.privilege);
    end loop;
    dbms_output.put_line('Privilegios del usuario '|| p_nombre || ' sobre objetos');
    for v_objeto in c_objetos loop
        dbms_output.put_line(CHR(9)||v_objeto.privilege || '---' || v_objeto.table_name);
    end loop;
end;
/

Realiza un procedimiento llamado listar_comisiones que nos muestre por pantalla un listado de las comisiones de los empleados agrupados según la localidad donde está ubicado su departamento con el siguiente formato:

Localidad NombreLocalidad

    Departamento: NombreDepartamento

        Empleado1 ……. Comisión 1
        Empleado2 ……. Comisión 2
        .
        .
        .
        Empleadon ……. Comision n

    Total Comisiones en el Departamento NombreDepartamento: SumaComisiones

    Departamento: NombreDepartamento

        Empleado1 ……. Comisión 1
        Empleado2 ……. Comisión 2
        .
        .
        .
        Empleadon ……. Comision n

    Total Comisiones en el Departamento NombreDepartamento: SumaComisiones
    .
    .
Total Comisiones en la Localidad NombreLocalidad: SumaComisionesLocalidad

Localidad NombreLocalidad
.
.

Total Comisiones en la Empresa: TotalComisiones

Nota: Los nombres de localidades, departamentos y empleados deben aparecer por orden alfabético.

Si alguno de los departamentos no tiene ningún empleado con comisiones, aparecerá un mensaje informando de ello en lugar de la lista de empleados.

El procedimiento debe gestionar adecuadamente las siguientes excepciones:

a) La tabla Empleados está vacía.
b) Alguna comisión es mayor que 10000.

He creado dos funciones y un procedimiento:

CREATE OR REPLACE FUNCTION listar_empleados(p_deptno dept.deptno%type)
return number
is
    cursor c_empleados is
        SELECT ename,comm
        from emp
        where deptno=p_deptno
        order by ename;
    v_vacio number;
    v_suma number:=0;
    v_valor number;
begin
    select sum(comm) into v_vacio from emp where deptno=p_deptno;
    if v_vacio>0 then
        for v_empleado in c_empleados loop
            IF v_empleado.comm is NULL THEN
                v_valor:=0;
            ELSE
                v_suma:=v_suma+v_empleado.comm;
                v_valor:=v_empleado.comm;
            END IF;
            dbms_output.put_line(CHR(9)||CHR(9)|| v_empleado.ename || ' ... ' || v_valor);
        end loop;
    else
        dbms_output.put_line(CHR(9)||CHR(9)|| 'El departamento no tiene comisiones');
    end if;
    return v_suma;
EXCEPTION
    WHEN NO_DATA_FOUND then
        dbms_output.put_line('La tabla empleados está vacía');
        return 0;
end;
/

CREATE OR REPLACE FUNCTION listar_departamentos(p_loc dept.loc%type)
return number
is
    cursor c_departamentos is
        SELECT dname,deptno
        from dept
        where loc=p_loc
        order by dname;
    v_total number;
    v_suma number:=0;
begin
    for v_departamento in c_departamentos loop
        dbms_output.put_line(CHR(9)|| 'Departamento: ' || v_departamento.dname);
        v_total:=listar_empleados(v_departamento.deptno);
        dbms_output.put_line(CHR(9)|| 'Total Comisiones en el Departamento ' || v_departamento.dname || ': ' || v_total);
        v_suma:=v_suma+v_total;
    end loop;
    return v_suma;
end;
/

CREATE OR REPLACE PROCEDURE listar_comisiones
is
    cursor c_localidades is
        SELECT loc
        from dept
        order by loc;
    v_total number;
    v_suma number:=0;
begin
    for v_localidad in c_localidades loop
        dbms_output.put_line('Localidad ' || v_localidad.loc);
        v_total:=listar_departamentos(v_localidad.loc);
        dbms_output.put_line('Total Comisiones en la Localidad ' || v_localidad.loc || ': ' || v_total);
        v_suma:=v_suma+v_total;
    end loop;
    dbms_output.put_line('Total Comisiones de la Empresa ' || v_suma);
end;
/

. Realiza un procedimiento que reciba el nombre de una tabla y muestre los nombres de las restricciones que tiene, a qué columna afectan y en qué consisten exactamente. (DBA_TABLES, DBA_CONSTRAINTS, DBA_CONS_COLUMNS)

He realizado los siguientes procedimientos:

CREATE OR REPLACE PROCEDURE listar_restriccion(p_nombre user_constraints.table_name%type,p_tabla user_constraints.table_name%type)
is
    v_tipo user_constraints.constraint_type%type;
    v_nombre user_constraints.constraint_name%type;
    v_referencia user_constraints.r_constraint_name%type;
    v_condicion user_constraints.search_condition%type;
begin
    select constraint_name,constraint_type,r_constraint_name,search_condition into v_nombre,v_tipo,v_referencia,v_condicion
    from user_constraints
    where table_name = p_tabla
    and constraint_name=p_nombre;
    if v_tipo='P' then
        dbms_output.put_line(p_nombre || ' ... es de tipo CLAVE PRIMARIA');
    elsif v_tipo='R' then
        dbms_output.put_line(p_nombre || ' ... es de tipo CLAVE EXTERNA y hace referencia a: ' || v_nombre);
    elsif v_tipo='C' then
        dbms_output.put_line(p_nombre || ' ... es de tipo CHECK y contiene la siguiente comprobacion: ' || v_condicion); 
    end if;
end;
/

CREATE OR REPLACE PROCEDURE listar_restricciones(p_tabla user_constraints.table_name%type)
is
    cursor c_columnas is
        SELECT constraint_name,column_name
        from user_cons_columns
        where table_name=p_tabla;
begin
    dbms_output.put_line('Restricciones de la tabla ' || p_tabla);
    for v_columna in c_columnas loop
        listar_restriccion(v_columna.constraint_name,p_tabla);
        dbms_output.put_line(CHR(9)||'Hace referencia a la columna -> ' || v_columna.column_name);
    end loop;
end;
/

En la comprobación introduzco una tabla diferente al esquema SCOTT ya que tiene más restricciones:

Realiza al menos dos de los ejercicios anteriores en Postgres usando PL/pgSQL.

Ejercicio 1

CREATE or replace PROCEDURE mostrarnombresalario() AS $$
DECLARE
    v_nombre emp.ename%type;
    v_salario emp.sal%type;
BEGIN
    select ename,sal into v_nombre,v_salario from emp where empno=7782;
    RAISE NOTICE 'El nombre del empleado es %, y su salario es %', v_nombre,v_salario;
END;
$$ LANGUAGE plpgsql;

Ejercicio 2

CREATE or replace PROCEDURE mostrarnombresalario2(p_empno emp.empno%type) AS $$
DECLARE
    v_nombre emp.ename%type;
BEGIN
    select ename into v_nombre from emp where empno=7782;
    RAISE NOTICE 'El nombre del empleado cuyo codigo es %, es %', p_empno,v_nombre;
END;
$$ LANGUAGE plpgsql;

Práctica 2: Interconexión de Servidores de Bases de Datos

Sun, 27 Nov 2022 00:00:00 GMT

Las interconexiones de servidores de bases de datos son operaciones que pueden ser muy útiles en diferentes contextos. Básicamente, se trata de acceder a datos que no están almacenados en nuestra base de datos, pudiendo combinarlos con los que ya tenemos. En esta práctica veremos varias formas de crear un enlace entre distintos servidores de bases de datos. Se pide:

Realizar un enlace entre dos servidores de bases de datos ORACLE, explicando la configuración necesaria en ambos extremos y demostrando su funcionamiento.
Realizar un enlace entre dos servidores de bases de datos Postgres, explicando la configuración necesaria en ambos extremos y demostrando su funcionamiento.
Realizar un enlace entre un servidor ORACLE y otro Postgres o MySQL empleando Heterogeneus Services

Enlace entre dos servidores ORACLE

En mi caso, las dos máquinas tienen la configuración siguiente; Tienen instalado Rocky 8 Oracle Database 19c Enterprise Edition, y tienen los siguientes nombres e IPs:

oracle-maquina1: 192.168.122.204
oracle-maquina2: 192.168.122.80

En ambas bases de datos existe el usuario roberto y están configuradas para el acceso remoto. Para comprobar que pueden acceder se utiliza el comando tnsping:

Ahora, para que los servidores puedan conectarse entre ellos, tenemos que añadir los datos de las máquinas al fichero /opt/oracle/product/19c/dbhome_1/network/admin/tnsnames.ora, dejándolos de la siguiente manera:

En el fichero dentro de la máquina 1:

MAQUINA2 =
    (DESCRIPTION =
        (ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.122.80)(PORT = 1521))
        (CONNECT_DATA =
            (SERVER = DEDICATED)
            (SERVICE_NAME = ORCLCDB)
        )
    )

En el fichero dentro de la máquina 2:

MAQUINA1 =
    (DESCRIPTION =
        (ADDRESS = (PROTOCOL = TCP)(HOST = 192.168.122.80)(PORT = 1521))
        (CONNECT_DATA =
            (SERVER = DEDICATED)
            (SERVICE_NAME = ORCLCDB)
        )
    )

Tras eso hay que crear los enlaces haciendo referencia al usuario (roberto). los comandos se ejecutan dentro de oracle:

En la máquina 1:

create database link enlace2 connect to roberto identified by roberto using 'maquina2';

En la máquina 2:

create database link enlace1 connect to roberto identified by roberto using 'maquina1';

Podemos comprobar que se puede acceder remotamente a las tablas:

Enlace entre dos servidores Postgres

En mi caso, las dos máquinas tienen la configuración siguiente; Tienen instalado Debian 11,MariaDB y PostgreSQL, y tienen los siguientes nombres e IPs:

mariadb-maquina1: 192.168.122.97
mariadb-maquina2: 192.168.122.90

En ambas bases de datos existe el usuario roberto y están configuradas para el acceso remoto.

Ahora vamos a crear el enlace:

apt install postgresql-contrib
psql -d scott
create extension dblink;

Una vez hecho eso, tenemos que ejecutar los siguientes comandos:

Máquina 1:

SELECT dblink_connect('dblink2','dbname=scott host=192.168.122.90 user=roberto password=roberto');

Máquina 2:

SELECT dblink_connect('dblink1','dbname=scott host=192.168.122.97 user=roberto password=roberto');

Tras eso, podemos realizar consultas entre máquinas:

Enlace entre un servidor ORACLE y uno Postgres

En este caso las máquinas que voy a conectar son oracle-maquina1 y mariadb-maquina2, por lo que las direcciones IP son las siguientes:

oracle-maquina1: 192.168.122.204
mariadb-maquina2: 192.168.122.90

Conexión desde Postgres a ORACLE

Primero descargamos los siguientes paquetes:

apt install libaio1 postgresql-server-dev-all build-essential git alien -y

Ahora tenemos que descargar el instantclient de oracle, se hace con los siguientes comandos:

wget https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-basic-21.8.0.0.0-1.el8.x86_64.rpm
wget https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-devel-21.8.0.0.0-1.el8.x86_64.rpm
wget https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-sqlplus-21.8.0.0.0-1.el8.x86_64.rpm

sudo alien -i --scripts oracle-instantclient-*

Una vez instalado, con el siguiente comando podemos conectarnos a la base de datos de oracle-maquina1:

sqlplus roberto/roberto@192.168.122.204:1521/ORCLCDB

Ahora tenemos que descargar y compilar oracle_fdw:

wget https://github.com/laurenz/oracle_fdw/archive/refs/tags/ORACLE_FDW_2_5_0.zip
unzip ORACLE_FDW_2_5_0.zip

Renombramos la carpeta:

mv oracle_fdw-ORACLE_FDW_2_5_0/ oracle_fdw

Finalmente compilamos el programa:

cd oracle_fdw
make
make install

Ahora, dentro de psql (y de la base de datos scott) creamos el enlace. Podemos comprobar que se ha creado con \dx:

CREATE EXTENSION oracle_fdw;

Creamos el schema en el que se van a importar las bases de datos de Oracle:

create schema oracle;

Configuramos un servidor foráneo que haga referencia a la base de datos Oracle en la otra máquina:

create server oracle foreign data wrapper oracle_fdw options (dbserver '//192.168.122.204/ORCLCDB');

Ahora creamos una equivalencia entre un usuario local y el del servidor (aunque en este caso se llaman igual):

create user mapping for roberto server oracle options (user 'roberto', password 'roberto');

Le damos permisos al usuario local sobre el schema de oracle:

grant all privileges on schema oracle to roberto;
grant all privileges on foreign server oracle to roberto;

Iniciamos sesión en psql con el usuario que hemos indicado en los pasos anteriores, e importamos el esquema remoto:

psql -U roberto -W -d scott

import foreign schema "ROBERTO" from server oracle into oracle;

Conexión desde Oracle a Postgres

Para realizar la conexión vamos a utilizar ODBC (Open Database Conectivity); y en este caso ya que vamos a realizar la conexión con PostgreSQL, también tenemos que descargar el paquete específico:

dnf install unixODBC postgresql-odbc

Ahora en el fichero de configuración /etc/odbcinst.ini comentamos todas las líneas menos las referentes a postgresql, quedando el fichero de la siguiente manera:

[PostgreSQL]
Description     = ODBC for PostgreSQL
Driver          = /usr/lib/psqlodbcw.so
Setup           = /usr/lib/libodbcpsqlS.so
Driver64        = /usr/lib64/psqlodbcw.so
Setup64         = /usr/lib64/libodbcpsqlS.so
FileUsage       = 1

Para configurar el acceso a la máquina con postgres tenemos que crear en el fichero /etc/odbc.ini la siguiente entrada:

[PSQLU]

Debug = 0
CommLog = 0
ReadOnly = 0
Driver = PostgreSQL
Servername = 192.168.122.90
Username = roberto
Password = roberto
Port = 5432
Database = scott
Trace = 0
TraceFile = /tmp/sql.log

Podemos comprobar que funciona con isql PSQLU.

Ahora hay que crear la configuración para que Oracle pueda hacer uso del driver. Para ello tenemos que crear el fichero /opt/oracle/product/19c/dbhome_1/hs/admin/initPSQLU.ora con el siguiente contenido:

HS_FDS_CONNECT_INFO = PSQLU
HS_FDS_TRACE_LEVEL = DEBUG
HS_FDS_SHAREABLE_NAME = /usr/lib64/psqlodbcw.so
HS_LANGUAGE = AMERICAN_AMERICA.WE8ISO8859P1
set ODBCINI=/etc/odbc.ini

También hay que configurar el listener /opt/oracle/product/19c/dbhome_1/network/admin/listener.ora, añadiendo lo siguiente al final:

SID_LIST_LISTENER =
    (SID_LIST =
        (SID_DESC =
            (SID_NAME = PSQLU)
            (ORACLE_HOME=/opt/oracle/product/19c/dbhome_1)
            (PROGRAM=dg4odbc)
        )
    )

Y añadimos una entrada de conexión a /opt/oracle/product/19c/dbhome_1/network/admin/tnsnames.ora:

PSQLU =
    (DESCRIPTION=
        (ADDRESS=(PROTOCOL=tcp)(HOST=localhost)(PORT=1521))
        (CONNECT_DATA=(SID=PSQLU))
        (HS=OK)
    )

Ahora reiniciamos el listener y creamos el enlace dentro de oracle.

create database link postgreslink connect to "roberto" identified by"roberto" using 'PSQLU';

Ya está creado el enlace. Ahora para comprobar que funciona, podemos hacer una consulta:

SELECT "ename" FROM "emp"@postgreslink;

Aplicacion web MySQL

Mon, 31 Oct 2022 00:00:00 GMT

Instalación

instalamos php:

apt install apache2 libapache2-mod-php php php-mysql
apt install php-zip php-gd php-mbstring phpmyadmin -y

Configuración

En la instalación de phpmyadmin elegimos como servidor apache2, después, cuando nos pregunta por una contraseña, le damos a Sí, e introducimos una contraseña para phpmyadmin dos veces

Una vez instalado, para poder acceder con un usuario concreto, tenemos que hacer lo siguiente:

Entramos en el directorio de phpmyadmin y copiamos un fichero de ejemplo para utilizarlo como configuración:

cd /usr/share/phpmyadmin/
cp config.sample.inc.php config.inc.php

en el fichero config.inc.php tenemos que añadir a blowfish_secret una cadena de 30 caracteres, y tenemos que descomentar las lineas de controlusery controlpass y añadirles las credenciales.

Una vez realizada la configuración, reiniciamos el servicio:

systemctl reload apache2

Prueba

y podemos acceder a la página de administración en http://IPmaquina/phpmyadmin/:

Aplicacion web Oracle

Sun, 30 Oct 2022 00:00:00 GMT

Aplicación web Oracle programada en python.

Preparación

Antes de crear el fichero que va a ser la aplicación, vamos a crear un Entorno virtual (Venv) de python para contener ahí los módulos que nos descarguemos

mkdir aplicacion_web_oracle && cd aplicacion_web_oracle
python3 -m venv /home/roberto/aplicacion_web_oracle
source bin/activate

Ahora vamos a descargar los módulos necesarios:

pip install cx_oracle
pip install flask

Ahora, usando flask, se ha escrito la siguiente aplicación sencilla, que permite, al introducirle el nombre de un empleado en la dirección /emp/, mostrar los datos de dicho empleado. Es importante que, cuando se define pool se introduzcan los mismo datos que en el acceso remoto a oracle, ya que esta aplicación se ha creado desde una máquina distina a la de oracle.

import os
import sys
import cx_Oracle
from flask import Flask

def init_session(connection, requestedTag_ignored):
    cursor = connection.cursor()
    cursor.execute("""
        ALTER SESSION SET
          TIME_ZONE = 'UTC'
          NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI'""")

# start_pool(): starts the connection pool
def start_pool():
    pool_min = 4
    pool_max = 4
    pool_inc = 0
    pool_gmd = cx_Oracle.SPOOL_ATTRVAL_WAIT

    print("Connecting to", "192.168.122.105:1521/ORCLCDB")

    pool = cx_Oracle.SessionPool(user="roberto",
                                 password="roberto",
                                 dsn="192.168.122.105:1521/ORCLCDB",
                                 min=pool_min,
                                 max=pool_max,
                                 increment=pool_inc,
                                 threaded=True,
                                 getmode=pool_gmd,
                                 sessionCallback=init_session)

    return pool

app = Flask(__name__)

@app.route('/')
def index():
    return "Entra en /emp/nombreempleado para ver los datos del empleado"


# Show the username for a given id
@app.route('/emp/<string:name>')
def show_username(name):
    connection = pool.acquire()
    cursor = connection.cursor()
    cursor.execute("select * from emp where ename = (:name)", [name])
    r = cursor.fetchone()
    r = str(r)
    return (r)

################################################################################
#
# Initialization is done once at startup time
#
if __name__ == '__main__':

    # Start a pool of connections
    pool = start_pool()


    # Start a webserver
    app.run(port=int(os.environ.get('PORT', '8080')))

Conexiones desde clientes a servidores con bases de datos

Sun, 30 Oct 2022 00:00:00 GMT

Vamos a realizar conexiones desde los clientes de BBDD a sus respectivos servidores.

Oracle

En el lado del servidor, tiene que estar activo oracle (startup), también como se ha hecho en la instalación tiene que estar activado el listener

lsnrctl start

y el firewall tiene que permitir el puerto 1521

firewall-cmd --permanent --add-port=1521/tcp
firewall-cmd --reload

Para conectarnos de manera remota a oracle, tenemos que descargar en el lado del cliente instantclient, del siguiente enlace. En él hay varios enlaces de descarga. Los que nos interesan son:

https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-basic-21.8.0.0.0-1.el8.x86_64.rpm
https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-devel-21.8.0.0.0-1.el8.x86_64.rpm
https://download.oracle.com/otn_software/linux/instantclient/218000/oracle-instantclient-sqlplus-21.8.0.0.0-1.el8.x86_64.rpm

En mi caso, el cliente es debian, así que tenemos que instalar los paquetes usando alien:

sudo alien -i --scripts oracle-instantclient-*

Una vez instalados, podemos acceder al servidor con sqlplus, donde la sintaxis es

sqlplus [USUARIO]/[CONTRASEÑA]@[IP:PUERTO]/[NOMBREBD]

sqlplus roberto/roberto@192.168.122.105:1521/ORCLCDB

En la captura se puede ver una consulta de prueba para comprobar que se ha accedido a la base de datos correctamente.

MariaDB

Para conectarnos tenemos que instalar el paquete mariadb-client:

sudo apt install mariadb-client

Una vez instalado, ya podemos acceder al servidor. El comando tiene la siguiente sintaxis:

mariadb --host FULLY_QUALIFIED_DOMAIN_NAME --port TCP_PORT \
     --user DATABASE_USER --password \
     --ssl-verify-server-cert \
     --ssl-ca PATH_TO_PEM_FILE

Lo utilizamos con las opciones de nuestro servidor:

mariadb --host 192.168.122.78 --port 3306 \
--user remoto --password

PostgreSQL

Para conectarnos tenemos que instalar el paquete postgresql-client

sudo apt install postgresql-client

Y nos conectamos al servidor usando el comando psql:

psql --host 192.168.122.78 --user roberto -d scott

Instalación de MariaDB y PostgreSQL en Debian

Wed, 26 Oct 2022 00:00:00 GMT

MariaDB

El paquete de MariaDB se encuentra en los repositorios de Debian, por lo que podemos instalarlo directamente con apt:

sudo apt update
sudo apt install mariadb-server -y

Entramos en la base de datos como root:

mysql -u root -p

Configuración para acceso remoto

Para poder acceder remotamente tenemos que modificar el archivo de configuración /etc/mysql/mariadb.conf.d/50-server.cnf, buscando la línea de bind-address y poniendo lo siguiente:

bind-address            = 0.0.0.0

A continuación reiniciamos el servicio de mariadb:

systemctl restart mariadb.service

Dentro de mariadb, tenemos que crear un usuario para el acceso remoto (el % es un comodín para indicar que se pueda acceder desde cualquier dirección):

GRANT ALL PRIVILEGES ON *.* TO 'remoto'@'%'
IDENTIFIED BY 'remoto' WITH GRANT OPTION;

Creación de usuario

Creamos un usuario con todos los privilegios:

GRANT ALL PRIVILEGES ON *.* TO 'roberto'@'localhost'
IDENTIFIED BY 'roberto' WITH GRANT OPTION;

Ahora podemos entrar con el usuario roberto:

mysql -u roberto -p

Creación de tablas

Vamos a crear el esquema scott en mysql:

create database scott;
use scott;

CREATE TABLE IF NOT EXISTS `dept` (
  `DEPTNO` int(11) DEFAULT NULL,
  `DNAME` varchar(14) DEFAULT NULL,
  `LOC` varchar(13) DEFAULT NULL
);
INSERT INTO `dept` (`DEPTNO`, `DNAME`, `LOC`) VALUES
(10, 'ACCOUNTING', 'NEW YORK'),
(20, 'RESEARCH', 'DALLAS'),
(30, 'SALES', 'CHICAGO'),
(40, 'OPERATIONS', 'BOSTON');
CREATE TABLE IF NOT EXISTS `emp` (
  `EMPNO` int(11) NOT NULL,
  `ENAME` varchar(10) DEFAULT NULL,
  `JOB` varchar(9) DEFAULT NULL,
  `MGR` int(11) DEFAULT NULL,
  `HIREDATE` date DEFAULT NULL,
  `SAL` int(11) DEFAULT NULL,
  `COMM` int(11) DEFAULT NULL,
  `DEPTNO` int(11) DEFAULT NULL
);
INSERT INTO `emp` (`EMPNO`, `ENAME`, `JOB`, `MGR`, `HIREDATE`, `SAL`, `COMM`, `DEPTNO`) VALUES
(7369, 'SMITH', 'CLERK', 7902, '1980-12-17', 800, NULL, 20),
(7499, 'ALLEN', 'SALESMAN', 7698, '1981-02-20', 1600, 300, 30),
(7521, 'WARD', 'SALESMAN', 7698, '1981-02-22', 1250, 500, 30),
(7566, 'JONES', 'MANAGER', 7839, '1981-04-02', 2975, NULL, 20),
(7654, 'MARTIN', 'SALESMAN', 7698, '1981-09-28', 1250, 1400, 30),
(7698, 'BLAKE', 'MANAGER', 7839, '1981-05-01', 2850, NULL, 30),
(7782, 'CLARK', 'MANAGER', 7839, '1981-06-09', 2450, NULL, 10),
(7788, 'SCOTT', 'ANALYST', 7566, '1982-12-09', 3000, NULL, 20),
(7839, 'KING', 'PRESIDENT', NULL, '1981-11-17', 5000, NULL, 10),
(7844, 'TURNER', 'SALESMAN', 7698, '1980-09-08', 1500, 0, 30),
(7876, 'ADAMS', 'CLERK', 7788, '1983-01-12', 1100, NULL, 20),
(7900, 'JAMES', 'CLERK', 7698, '1981-12-03', 950, NULL, 30),
(7902, 'FORD', 'ANALYST', 7566, '1981-12-03', 3000, NULL, 20),
(7934, 'MILLER', 'CLERK', 7782, '1982-01-23', 1300, NULL, 10);

PostgreSQL

El paquete de PostgreSQL se encuentra en los repositorios de Debian, por lo que podemos instalarlo directamente con apt:

sudo apt install postgreSQL

Accedemos al usuario postgres:

su postgres

Configuración para acceso remoto

Para poder acceder remotamente tenemos que modificar el archivo de configuración /etc/postgresql/13/main/postgresql.conf, buscando la línea de listen_addresses y poniendo lo siguiente:

listen_addresses = '*'

También, al final del fichero /etc/postgresql/13/main/pg_hba.conf tenemos que añadir las siguientes líneas:

host    all      all              0.0.0.0/0                    md5
host    all      all              ::/0                         md5

Reiniciamos el servicio para que los cambios tengan efecto:

systemctl restart postgresql.service

Ahora vamos a crear un usuario con contraseña para acceder desde fuera con el siguiente comando dentro de psql:

create user roberto with superuser password 'roberto';

Creación de tablas

Creamos la base de datos y accedemos a psql

createdb scott
psql

Dentro del intérprete de comandos añadimos el esquema scott:

\c scott

create table dept (
  deptno integer,
  dname  text,
  loc    text,
  constraint pk_dept primary key (deptno)
);
create table emp (
  empno    integer,
  ename    text,
  job      text,
  mgr      integer,
  hiredate date,
  sal      integer,
  comm     integer,
  deptno   integer,
  constraint pk_emp primary key (empno),
  constraint fk_mgr foreign key (mgr) references emp (empno),
  constraint fk_deptno foreign key (deptno) references dept (deptno)
);
insert into dept (deptno,  dname,        loc)
       values    (10,     'ACCOUNTING', 'NEW YORK'),
                 (20,     'RESEARCH',   'DALLAS'),
                 (30,     'SALES',      'CHICAGO'),
                 (40,     'OPERATIONS', 'BOSTON');
insert into emp (empno, ename,    job,        mgr,   hiredate,     sal, comm, deptno)
       values   (7369, 'SMITH',  'CLERK',     7902, '1980-12-17',  800, NULL,   20),
                (7499, 'ALLEN',  'SALESMAN',  7698, '1981-02-20', 1600,  300,   30),
                (7521, 'WARD',   'SALESMAN',  7698, '1981-02-22', 1250,  500,   30),
                (7566, 'JONES',  'MANAGER',   7839, '1981-04-02', 2975, NULL,   20),
                (7654, 'MARTIN', 'SALESMAN',  7698, '1981-09-28', 1250, 1400,   30),
                (7698, 'BLAKE',  'MANAGER',   7839, '1981-05-01', 2850, NULL,   30),
                (7782, 'CLARK',  'MANAGER',   7839, '1981-06-09', 2450, NULL,   10),
                (7788, 'SCOTT',  'ANALYST',   7566, '1982-12-09', 3000, NULL,   20),
                (7839, 'KING',   'PRESIDENT', NULL, '1981-11-17', 5000, NULL,   10),
                (7844, 'TURNER', 'SALESMAN',  7698, '1981-09-08', 1500,    0,   30),
                (7876, 'ADAMS',  'CLERK',     7788, '1983-01-12', 1100, NULL,   20),
                (7900, 'JAMES',  'CLERK',     7698, '1981-12-03',  950, NULL,   30),
                (7902, 'FORD',   'ANALYST',   7566, '1981-12-03', 3000, NULL,   20),
                (7934, 'MILLER', 'CLERK',     7782, '1982-01-23', 1300, NULL,   10);

MongoDB

Como indica la documentación oficial, Primero tenemos que añadir la clave a nuestros repositorios:

sudo apt install gnupg gnupg2 gnupg1
wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | sudo apt-key add -

Ahora añadimos el repositorio de mongo a los repositorios de debian:

echo "deb http://repo.mongodb.org/apt/debian buster/mongodb-org/6.0 main" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list

Y ahora, con los repositorios ya añadidos, instalamos mongodb:

sudo apt update
sudo apt install -y mongodb-org

Una vez instalado, iniciamos el servicio y activamos el inicio automático:

sudo systemctl start mongod
sudo systemctl enable mongod

Configuración de acceso remoto

Tenemos que editar el fichero /etc/mongod.conf y comentar la línea bindIP:

# bindIp: 127.0.0.1

y reiniciamos el servicio

sudo systemctl restart mongod

Creación de documentos

En este caso voy a insertar los datos de mi proyecto de MongoDB

mongoimport --db=yugioh --collection=prankkids --jsonArray --type json --file=prankkids.json

Podemos hacer una consulta para comprobar que se ha creado correctamente:

use yugioh
db.prankkids.find({"card_sets.set_name":"Hidden Summoners"}).count()

Instalación Oracle 19c en Rocky linux 8

Wed, 26 Oct 2022 00:00:00 GMT

Se va a realizar la instalación de Oracle 19c en Rocky linux 8, debido a su mayor compatibilidad con el programa y menor número de fallos que con Debian 11.

Pasos previos

Los siguientes pasos se deben ejecutar como usuario root. Actualizamos el sistema:

dnf makecache
dnf update -y

Si al ejecutarlo se actualiza el kernel, deberíamos reiniciar la máquina.

como indica la documentación, instalamos los requisitos previos. Sin embargo, al no estar en centos 7, tenemos que instalar manualmente unos paquetes

dnf install -y bc binutils compat-openssl10 elfutils-libelf glibc glibc-devel ksh libaio libXrender libX11 libXau libXi libXtst libgcc libnsl libstdc++ libxcb libibverbs make policycoreutils policycoreutils-python-utils smartmontools sysstat libnsl2 net-tools nfs-utils unzip
dnf install -y http://mirror.centos.org/centos/7/os/x86_64/Packages/compat-libcap1-1.10-7.el7.x86_64.rpm
dnf install -y http://mirror.centos.org/centos/7/os/x86_64/Packages/compat-libstdc++-33-3.2.3-72.el7.x86_64.rpm

Después descargamos los requisitos previos y los instalamos:

curl -o oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm https://yum.oracle.com/repo/OracleLinux/OL7/latest/x86_64/getPackage/oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm
yum -y localinstall oracle-database-preinstall-19c-1.0-1.el7.x86_64.rpm

Configuramos el firewall

firewall-cmd --permanent --add-port=1521/tcp
firewall-cmd --reload

configuramos el target mode de SELinux a permisivo:

sed -i 's/^SELINUX=.*/SELINUX=permissive/g' /etc/selinux/config
setenforce permissive

Instalación

Ahora descargamos el paquete rpm de la página oficial de oracle:

yum -y localinstall oracle-database-ee-19c-1.0-1.x86_64.rpm

Como nos indica al final de la instalación, creamos la base de datos de pruebas ejecutando el siguiente script:

/etc/init.d/oracledb_ORCLCDB-19c configure

Tras la ejecución, tenemos que iniciar sesión con el usuario oracle que se ha creado durante la misma, Y añadirle las siguientes variables al fichero .bash_profile

{{< highlight bash "linenos=table" >}} umask 022 export ORACLE_SID=ORCLCDB export ORACLE_BASE=/opt/oracle/oradata export ORACLE_HOME=/opt/oracle/product/19c/dbhome_1 export PATH=$PATH:$ORACLE_HOME/bin {{< / highlight >}}

Recargamos el fichero para que las variables tengan efecto:

source ~/.bash_profile

Tras este paso ya está instalado oracle, Ahora sigue crear la base de datos. Primero activamos el listener:

lsnrctl start

Para facilitar la utilización de sqlplus vamos a instalar el paquete rlwrap, que permite que utilicemos el cursor, tanto para desplazarnos por las líneas como para rescatar comandos.

dnf install epel-release
dnf install rlwrap -y

ahora creamos el siguiente alias en ~/.bashrc:

alias sqlplus='rlwrap sqlplus'

Configuración

Primero nos conectamos a la base de datos como sysdba:

sqlplus / as sysdba

y podemos comprobar la versión de oracle con la siguiente consulta:

SELECT instance_name, host_name, version, startup_time FROM v$instance;

Creación de usuario con privilegios

Vamos a crear un usuario para poder acceder a la base de datos sin utilizar el sysdba, con los siguientes comandos. Antes de crear el usuario, tenemos que activar _ORACLE_SCRIPT para que se puedan ejecutar sin errores los siguientes comandos:

alter session set "_ORACLE_SCRIPT"=true;
CREATE USER roberto IDENTIFIED BY roberto;
GRANT ALL PRIVILEGES TO roberto;

Una vez creado el usuario podemos conectarnos con él utilizando el siguiente comando:

sqlplus roberto/roberto

Creación de tablas

Vamos a introducir a modo de prueba, el esquema scott:

CREATE TABLE DEPT
(
 DEPTNO NUMBER(2),
 DNAME VARCHAR2(14),
 LOC VARCHAR2(13),
 CONSTRAINT PK_DEPT PRIMARY KEY (DEPTNO)
);
CREATE TABLE EMP
(
 EMPNO NUMBER(4),
 ENAME VARCHAR2(10),
 JOB VARCHAR2(9),
 MGR NUMBER(4),
 HIREDATE DATE,
 SAL NUMBER(7, 2),
 COMM NUMBER(7, 2),
 DEPTNO NUMBER(2),
 CONSTRAINT FK_DEPTNO FOREIGN KEY (DEPTNO) REFERENCES DEPT (DEPTNO),
 CONSTRAINT PK_EMP PRIMARY KEY (EMPNO)
);
INSERT INTO DEPT VALUES (10, 'ACCOUNTING', 'NEW YORK');
INSERT INTO DEPT VALUES (20, 'RESEARCH', 'DALLAS');
INSERT INTO DEPT VALUES (30, 'SALES', 'CHICAGO');
INSERT INTO DEPT VALUES (40, 'OPERATIONS', 'BOSTON');
INSERT INTO EMP VALUES(7369, 'SMITH', 'CLERK', 7902,TO_DATE('17-DIC-1980', 'DD-MON-YYYY'), 800, NULL, 20);
INSERT INTO EMP VALUES(7499, 'ALLEN', 'SALESMAN', 7698,TO_DATE('20-FEB-1981', 'DD-MON-YYYY'), 1600, 300, 30);
INSERT INTO EMP VALUES(7521, 'WARD', 'SALESMAN', 7698,TO_DATE('22-FEB-1981', 'DD-MON-YYYY'), 1250, 500, 30);
INSERT INTO EMP VALUES(7566, 'JONES', 'MANAGER', 7839,TO_DATE('2-ABR-1981', 'DD-MON-YYYY'), 2975, NULL, 20);
INSERT INTO EMP VALUES(7654, 'MARTIN', 'SALESMAN', 7698,TO_DATE('28-SEP-1981', 'DD-MON-YYYY'), 1250, 1400, 30);
INSERT INTO EMP VALUES(7698, 'BLAKE', 'MANAGER', 7839,TO_DATE('1-MAY-1981', 'DD-MON-YYYY'), 2850, NULL, 30);
INSERT INTO EMP VALUES(7782, 'CLARK', 'MANAGER', 7839,TO_DATE('9-JUN-1981', 'DD-MON-YYYY'), 2450, NULL, 10);
INSERT INTO EMP VALUES(7788, 'SCOTT', 'ANALYST', 7566,TO_DATE('09-DIC-1982', 'DD-MON-YYYY'), 3000, NULL, 20);
INSERT INTO EMP VALUES(7839, 'KING', 'PRESIDENT', NULL,TO_DATE('17-NOV-1981', 'DD-MON-YYYY'), 5000, NULL, 10);
INSERT INTO EMP VALUES(7844, 'TURNER', 'SALESMAN', 7698,TO_DATE('8-SEP-1981', 'DD-MON-YYYY'), 1500, 0, 30);
INSERT INTO EMP VALUES(7876, 'ADAMS', 'CLERK', 7788,TO_DATE('12-ENE-1983', 'DD-MON-YYYY'), 1100, NULL, 20);
INSERT INTO EMP VALUES(7900, 'JAMES', 'CLERK', 7698,TO_DATE('3-DIC-1981', 'DD-MON-YYYY'), 950, NULL, 30);
INSERT INTO EMP VALUES(7902, 'FORD', 'ANALYST', 7566,TO_DATE('3-DIC-1981', 'DD-MON-YYYY'), 3000, NULL, 20);
INSERT INTO EMP VALUES(7934, 'MILLER', 'CLERK', 7782,TO_DATE('23-ENE-1982', 'DD-MON-YYYY'), 1300, NULL, 10);

COMMIT;

Las tablas se crean sin errores y se introducen los valores. Podemos realizar una consulta sencilla:

SELECT ename
FROM emp
WHERE deptno = (SELECT deptno
                FROM dept
                WHERE dname = 'SALES');

Ansible: Escenario router-nat

Tue, 18 Oct 2022 00:00:00 GMT

Creación del siguiente escenario con un cliente y un router-nat utilizando vagrant y ansible

Vagrant

Según el esquema de red que tenemos que replicar, vamos a crear una red muy aislada entre las dos máquinas. También, el router tendrá un bridge que será su puerta de enlace predeterminada. En el caso del cliente, esta configuración se hará más adelante. El Vagrantfile queda de la siguiente manera:

{{< highlight ruby "linenos=table">}} config.vm.define :router do |router| router.vm.box = "debian/bullseye64" router.vm.hostname = "router" router.vm.synced_folder ".", "/vagrant", disabled: true router.vm.network :public_network, :dev => "br0", :mode => "bridge", :type => "bridge", use_dhcp_assigned_default_route: true router.vm.network :private_network, :libvirt__network_name => "red-muy-aislada", :libvirt__dhcp_enabled => false, :ip => "192.168.0.1", :libvirt__forward_mode => "veryisolated" end config.vm.define :cliente do |cliente| cliente.vm.box = "debian/bullseye64" cliente.vm.hostname = "cliente" cliente.vm.synced_folder ".", "/vagrant", disabled: true cliente.vm.network :private_network, :libvirt__network_name => "red-muy-aislada", :libvirt__dhcp_enabled => false, :ip => "192.168.0.2", :libvirt__forward_mode => "veryisolated" end end {{< / highlight >}}

Creamos las máquinas virtuales:

vagrant up

Ansible

Ahora nos movemos al directorio donde se va a encontrar el playbook (ansible/). empezamos por el fichero hosts;

hosts

El fichero hosts contiene la información de las máquinas en las que vamos a realizar el despliegue, pero antes de crearlo necesitamos conseguir las direcciones IPs que tienen asignadas en la interfaz eth0 (la de Vagrant). Para ello usamos el siguiente comando:

{{< highlight bash "hl_lines=2" >}} $ vagrant ssh cliente -c "hostname -I | cut -d' ' -f1" 2>/dev/null 192.168.121.77 {{< / highlight >}}

{{< highlight bash "hl_lines=6" >}} $ vagrant ssh router -c "hostname -I | cut -d' ' -f1" 2>/dev/null ==> router: You assigned a static IP ending in ".1" to this machine. ==> router: This is very often used by the router and can cause the ==> router: network to not work properly. If the network doesn't work ==> router: properly, try changing this IP. 192.168.121.146 {{< / highlight >}}

Nos aparece una alerta ya que el router tiene una dirección IP acabada en ".1", Lo ignoramos ya que la máquina es el router de la red. Con la salida de ambos comandos tenemos las IPs de las máquinas y, añadiendo además las rutas de las claves privadas, podemos crear el fichero:

{{< highlight yaml "linenos=table,hl_lines=6 10" >}} all: children: maquinas: hosts: cliente: ansible_ssh_host: 192.168.121.77 ansible_ssh_user: vagrant ansible_ssh_private_key_file: ../.vagrant/machines/cliente/libvirt/private_key router: ansible_ssh_host: 192.168.121.146 ansible_ssh_user: vagrant ansible_ssh_private_key_file: ../.vagrant/machines/router/libvirt/private_key {{< / highlight >}}

Ahora podemos crear las máquinas con vagrant up:

site.yaml

Tras eso creamos el fichero que contiene la información de asignación de roles, que deben ser de la siguiente manera:

common: Estas tareas se deben ejecutar en todos los nodos: actualizar los paquetes y añadir tu clave pública a la máquinas para poder acceder a ellas con ssh. ¿Existe algún módulo de ansible que te permita copiar claves públicas?.
router: Todas las tareas necesarias para configurar router cómo router-nat y que salga a internet por eth1. Las configuraciones deben ser permanentes. ¿Existe algún módulo de ansible que te permita ejecutar sysctl?.
cliente: Todas las tareas necesarias para que las máquinas conectadas a la red privada salgan a internet por eth1.
web: Las tareas necesarias para instalar y configurar un servidor web con una página estática en la máquina cliente.

hosts: all become: true roles:
- role: common
hosts: router become: true roles:
- role: router
hosts: cliente become: true roles:
- role: web
- role: cliente {{< / highlight >}}

Roles

Para realizar el despliegue indicado tenemos que crear los roles. Las tareas de los roles, están contenidas en una estructura de carpetas dentro de la carpeta rol, siendo de la siguiente manera:

rolejemplo
├── defaults
├── files
├── handlers
├── library
├── tasks
├── templates
└── vars

conteniendo las tareas que realizará. Empezaremos por common:

Common

Este rol es bastante sencillo ya que solo cuenta con un fichero tasks/main.yaml que contiene la instrucción para comprobar que el sistema está actualizado:

name: Comprueba que el sistema esta actualizado apt: update_cache=yes upgrade=yes
name: Introduce la clave publica desde un fichero authorized_key: user: vagrant state: present key: "{{ lookup('file', '/home/roberto/.ssh/id_rsa.pub') }}" {{< / highlight >}}

Router

Todas las tareas necesarias para configurar router cómo router-nat y que salga a internet por eth1. Las configuraciones deben ser permanentes. El contenido de tasks/main.yaml es el siguiente:

name: Cambia el bit de forward a 1 ansible.posix.sysctl: name: net.ipv4.ip_forward value: '1' sysctl_set: yes state: present reload: yes
name: Configuracion de DNAT iptables: chain: PREROUTING in_interface: eth1 destination_port: 80 jump: DNAT protocol: tcp table: nat to_destination: 10.0.0.2:80 become: yes
name: Configuracion de SNAT iptables: chain: POSTROUTING destination: 10.0.0.0/8 jump: MASQUERADE out_interface: eth1 table: nat become: yes {{< / highlight >}}

Web

Las tareas necesarias para instalar y configurar un servidor web con una página estática en la máquina cliente. El contenido de tasks/main.yaml es el siguiente:

name: "ensure apache2 is installed" apt: pkg: apache2
name: copy template index template: src: index.j2 dest: /var/www/html/index.html owner: www-data group: www-data mode: 0644
name: "Copiar fichero al servidor remoto" copy: src: fichero.html dest: /var/www/html/fichero.html owner: www-data group: www-data mode: '0644'
name: "Copiar fichero de configuración y reiniciar el servicio" copy: src: etc/apache2/ports.conf dest: /etc/apache2/ports.conf owner: root group: root mode: '0644' notify: restart apache2 {{< / highlight >}}

En esta tarea si que se utilizan otros ficheros, pero al no tener una configuración crucial, no vamos a modificarlos. Su contenido se encuentra en github.

Cliente

Todas las tareas necesarias para que las máquinas conectadas a la red privada salgan a internet por eth1. El contenido de tasks/main.yaml es el siguiente:

name: cambiar la ruta por defecto shell: ip route delete default && ip route add default via 10.0.0.1 && echo "post-up route add -net 10.0.0.0 netmask 255.0.0.0 gw 10.0.0.0 dev eth1" >> /etc/network/interfaces {{< / highlight >}}

Finalmente, podemos ejecutar el playbook con ansible-playbook site.yaml:

Compilación de un programa en C utilizando un Makefile

Sun, 16 Oct 2022 00:00:00 GMT

Enunciado: Elige el programa escrito en C que prefieras y comprueba en las fuentes que exista un fichero Makefile o Configure. Deberás compilar desde las fuentes. Realiza los pasos necesarios para compilarlo e instálalo en tu equipo en un directorio que no interfiera con tu sistema de paquetes (/opt, /usr/local, etc.) La corrección se hará en clase y deberás ser capaz de explicar qué son todos los ficheros que se hayan instalado y realizar una desinstalación limpia.

El programa elegido es htop, ya que está escrito en C. De momento no tiene ninguno de los ficheros requeridos, pero ejecutando el script autogen.sh se crea el fichero configure.

Instalación

Para obtener las fuentes ejecutamos el siguiente comando:

apt source htop

wget http://deb.debian.org/debian/pool/main/h/htop/htop_3.0.5.orig.tar.gz
tar -xvf htop_3.0.5.orig.tar.gz

Configure

De momento el fichero no existe. Ejecutamos autogen.sh. Necesitaremos además el paquete autoconf:

sudo apt install autoconf

./autogen.sh

Podemos comprobar que se ha generado el fichero configure: Podemos ejecutar el fichero configure directamente. Sin embargo, de cara a una desinstalación más sencilla y a poder tener más localizados los ficheros instalados, vamos a cambiar la ruta que hay por defecto, al directorio opt. Se hace añadiendo la siguiente opción:

sudo mkdir /opt/htop
./configure --prefix=/opt/htop/

En el caso de que se de algún error en la salida del comando, hay que instalar las dependencias indicadas, y repetir el paso anterior.

sudo apt install libncurses*

Makefile

Para poder ejecutar make necesitamos el paquete build-essential, que contiene las utilidades esenciales para compilar un paquete en Debian.

sudo apt install build-essential

Para instalar el paquete ejecutamos:

sudo make install
sudo make clean

Para generar el fichero .deb es necesario que el paquete descargado sea con apt source, o la versión específica de debian.

o bien, para generar el fichero .deb:

instalamos las siguientes dependencias:

sudo apt install libnl-3-dev libnl-genl-3-dev libsensors-dev pkg-config debhelper-compat
# o bien con apt-get build-dep
sudo apt-get build-dep htop

make
dpkg-buildpackage -b
make clean
sudo dpkg -i ../htop_3.0.5-7_amd64.deb

El paquete ya está instalado. Podemos comprobar los ficheros creados en /opt: Entre los ficheros que aparecen, los más importantes son el propio binario de htop, y el manual. Para poder utilizar el comando la terminal tenemos que añadirlo al PATH. Para hacerlo, añadimos la siguiente línea al fichero .bashrc:

export PATH="/opt/htop/bin:$PATH"

Manual

Ya que lo hemos instalado en un directorio personal, no se ha creado el manual. Para hacerlo tenemos que crear un enlace simbólico:

sudo mkdir /usr/local/man/man1
sudo ln -s /opt/htop/share/man/man1/* /usr/local/man/man1/

Desinstalación

Para desinstalar el paquete vamos a utilizar otra vez el comando make, esta vez con la opción uninstall:

sudo make uninstall

Tras eso, comprobamos si queda algo en la ubicación de la instalación: la estructura de carpetas no se ha borrado, la borramos de manera manual. Por último, hay que eliminar la línea de .bashrc que añade la ruta al PATH y eliminar el enlace simbólico:

sudo rm /usr/local/man/man1/htop.1

Envío de alertas de Snort utilizando postfix

Fri, 14 Oct 2022 00:00:00 GMT

En esta entrada vamos a configurar un servidor de correos postfix para poder monitorizar las alertas que da snort de manera remota. Para ello vamos a utilizar el servidor por medio del comando swatch, que se encargará de comprobar el log de snort.

Postfix

Instalación

Antes de iniciar la instalación tenemos que comprobar el nombre de nuestra máquina, con el comando

hostname

Para instalar postfix previamente tenemos que instalar mailutils:

sudo apt update
sudo apt install mailutils
sudo apt install postfix

Tras la instalación de postfix, Se inciará un setup. En él seleccionamos Internet site, la opción por defecto. En el siguiente paso, si no está ya, introducimos el nombre de la máquina que consultamos antes.

Configuración

Una vez instalado, tenemos que editar varias líneas en el fichero de configuración: /etc/postfix/main.cf; tenemos que cambiar las siguientes líneas:

inet_interfaces = loopback-only
mydestination = $myhostname, localhost.$your_domain, $your_domain

Tras eso reiniciamos el servicio

sudo systemctl restart postfix

Con la configuración actual, no podemos enviar correos a una dirección de correo habitual (gmail, hotmail..) ya que nuestro servidor postfix no tiene autentificación SASL ni encriptación SLS, por lo que los proveedores de correo lo rechazan automáticamente.

Para comprobar que funciona podemos enviar un correo de prueba. Para el ejemplo, vamos a enviarlo a un correo temporal como este, ya que no realiza las mismas comprobaciones que gmail.

Enviamos el correo con el siguiente comando:

echo "Cuerpo del mensaje" | mail -s "Asunto del mensaje" correoelectronico

Para más información: instalación postfix, SASL y SLS

Alertas snort

Para que se envien correos al recibir alertas necesitamos el paquete swatchdog. Tras la instalación, en el fichero .swatchdogrc del directorio personal tiene que haber el siguiente contenido:

watchfor /Priority: 0/ exec echo "Mira el log de snort" | mail -s "ALERTA DE SNORT" correoelectronico, throttle 1:00

y lo ejecutamos:

swatchdog  -t /var/log/snort/alert

Para que Snort Genere las alertas en el fichero alert se ejecuta con el siguiente comando:

snort -A full -q -u snort -g snort -c /etc/snort/snort.conf -i eth1

Snort: Instalación y primeros pasos

Mon, 10 Oct 2022 00:00:00 GMT

Enunciado:

Instalación
Configuración Red
Reglas def
Reglas propias
Opciones reglas
Demo uso
Alertas
Acciones

Instalación

El paquete de Snort se encuentra en los repositorios de debian, por lo que podemos instalarlo directamente con apt:

sudo apt update
sudo apt install snort

con snort -V podemos comprobar que se ha instalado correctamente:

Configuración de la red

Tras instalarlo, iniciará la configuración de la red. En la configuración que se abre, podemos seleccionar la ip/rango de ips de la máquina, aunque más adelante modificando el fichero de configuración, podemos elegir que utilice solo una interfaz de red o todas (la opción por defecto). Para modificar las opciones tras la instalación tenemos que modificar el fichero /etc/snort/snort.debian.conf (al tratarse de una instalación en debian, se carga el contenido de este fichero antes que la propia configuración de snort). Concretamente nos interesan las siguientes líneas:

DEBIAN_SNORT_STARTUP="boot" DEBIAN_SNORT_HOME_NET="10.0.0.0/8" DEBIAN_SNORT_OPTIONS="" DEBIAN_SNORT_INTERFACE="enp7s0" DEBIAN_SNORT_SEND_STATS="false" DEBIAN_SNORT_STATS_RCPT="root" DEBIAN_SNORT_STATS_THRESHOLD="1"

Como el propio fichero indica, después de modificarlo tenemos que ejecutar el siguiente comando para que la configuración se actualice:

sudo dpkg-reconfigure snort

Tras la ejecución del comando, reconfiguramos Snort, decidiendo cuando se ejecuta, las interfaces e ips, si activamos el modo promiscuo, y por último si queremos que se cree una tarea de cron para mandar correos diariamente con el resultado del log.

Reglas

Para configurar los grupos de reglas que queremos activar, tenemos que editar el fichero de configuración /etc/snort/snort.conf: En la instalación que se realiza de los repositorios de debian, están incluidas las reglas de la comunidad. En el caso de que queramos utilizar una set de reglas concreta, habría que descomentar el set específico. También se puede observar en la imagen como el fichero de reglas personalizadas está activo (local.rules).

Reglas propias

De momento el fichero de reglas propias está vacío. Las reglas se construyen de la siguiente manera: Como podemos ver, La regla consta de dos partes principales, la cabecera, que contiene información relacionada con la red, y las opciones, que contienen detalles de invenstigación de paquetes. La regla que se muestra a continuación, sirve para detectar que se está realizando un ping a la máquina:

alert icmp any any -> $HOME_NET any (msg:"Ping detectado";sid:1000001;rev:1)

vamos a analizar la regla:

Estructura	Valor	Descripción
Action	alert	le dice a snort que hacer cuando la regla salta
Protocol	icmp	Protocolo a ser analizado (TCP, UDP, ICMP, IP)
Source IP	any	Direcciones IP de origen
Source Port	any	Puertos de origen
Direction	->	Operador de dirección. Determina la dirección del tráfico
Destination IP	$HOME_NET	Direcciones IP de destino
Destination Port	any	Puertos de destino
Message	msg:"Ping detectado"	Mensaje a mostrar cuando aplique la regla
Rule ID	sid:1000001	ID único de la regla
Revision info	rev:1	Información de revisión

Demo de la regla

Una vez hemos añadido al regla al fichero de local.rules, ya podemos probar la regla. Vamos a ejecutar snort en modo consola para que muestre el resultado en pantalla (-A console):

sudo snort -A console -q -c /etc/snort/snort.conf -i enp1s0

MHicxeRVZ6cSE6usNUu2HNRbI

Instalación de Debian desatendida

Thu, 06 Oct 2022 00:00:00 GMT

Creación de imagen

Descomprimimos la imagen

Vamos a utilizar la versión de debian que contiene software privativo, para, por ejemplo, tener disponibles más drivers en caso de que fueran necesarios. Tenemos que seguir los siguientes pasos:

Descargamos la imagen de la página de debian:

$ wget https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/current/amd64/iso-cd/firmware-11.5.0-amd64-netinst.iso

Descomprimimos la imagen utilizando xorriso en el directorio isofiles/:

$ xorriso -osirrox on -indev firmware-11.5.0-amd64-netinst.iso -extract / isofiles/

Introducimos el preseed

copiamos el fichero preseed.cfg a la raíz de la imagen:

$ sudo cp preseed.cfg isofiles/preseed.cfg

Editamos el fichero txt.cfg (encargado del contenido del menú inicial de instalación) para añadir una opción que utilice el preseed además de que cargue el idioma español:

$ sudo nano isofiles/isolinux/txt.cfg

label install
        menu label ^Install
        kernel /install.amd/vmlinuz
        append vga=788 initrd=/install.amd/initrd.gz --- quiet
label unattended-gnome
        menu label ^Instalacion Debian Desatendida Preseed
        kernel /install.amd/gtk/vmlinuz
        append vga=788 initrd=/install.amd/gtk/initrd.gz preseed/file=/cdrom/preseed.cfg locale=es_ES console-setup/ask_detect=false keyboard-configuration/xkb-keymap=e>

Volvemos a generar la imagen

Como hemos alterado los ficheros que contiene la imagen, tenemos que generar un nuevo fichero md5sum.txt:

$ cd isofiles/
$ chmod a+w md5sum.txt
$ md5sum `find -follow -type f` > md5sum.txt
$ chmod a-w md5sum.txt
$ cd .

Por último cambiamos los permisos de isolinux y creamos la imagen nueva:

$ chmod a+w isofiles/isolinux/isolinux.bin
$ genisoimage -r -J -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -o debian-preseed.iso isofiles

Carga del fichero preseed.cfg desde red

Configuración del servidor

Para la instalación desatendida cargando el preseed desde red, es necesario una máquina que haga el rol de servidor, teniendo un servidor apache2 instalado. Para preparar dicha máquina seguimos los siguientes pasos:

Instalamos el servidor apache en la máquina:

$ apt upgrade && apt install apache2

copiamos el fichero preseed.cfg previamente configurado al directorio /var/www/html

Tras este paso, el servidor ya está configurado y ofreciendo la configuración a la red.

Utilización desde el cliente

Para aplicar la configuración del fichero preseed, iniciamos la instalación de una imagen de debian sin modificar. Para utilizarla tenemos dos opciones:

Utilizando línea de comandos:
1. Pulsamos la tecla ESC para abrir la línea de comandos
2. Introducimos el siguiente comando para acceder al fichero, donde IP servidor es la ip de la máquina que tiene el servidor apache:

boot: auto url=[IP servidor]/preseed.cfg

Utilizando las opciones avanzadas:
1. Accedemos a opciones avanzadas en el menú, seguido de instalación automatizada.
2. Introducimos la ip del servidor con apache de la siguiente manera:

http://[IP servidor]/preseed.cfg

Tras esto, la instalación desatendida comenzará.

Instalación basada en preseed/PXE/TFT

Para esta instalación, al igual que la anterior, es necesario que una máquina haga el rol de servidor, además en este caso tiene que tener un servidor DHCP. Para configurarla vamos a seguir los siguientes pasos. La máquina tiene que tener una red aislada sin DHCP en la que se va a conectar con los clientes

Instalación de dnsmasq

Instalamos el paquete dnsmasq, encargado tanto del DHCP como del servidor TFTP

$ apt install dnsmasq

configuramos el contenido del fichero /etc/dnsmasq.conf/:

dhcp-range=192.168.100.50,192.168.100.150,255.255.255.0,12h
dhcp-boot=pxelinux.0
enable-tftp
tftp-root=/srv/tftp

En el paso anterior especificamos que se utilizara el directorio /srv/tftp/ como raíz para la transmisión por pxe; vamos a crearlo:

$ mkdir /srv/tftp/

Reiniciamos el servicio para que los cambios tengan efecto

$ systemctl restart dnsmasq

Descarga de la imagen

Para instalar utilizando PXE/TFTP tenemos que utilizar una imagen de debian especial llamada netboot. Esta imagen se encuentra en la siguiente dirección: http://ftp.debian.org/debian/dists/bullseye/main/installer-amd64/current/images/netboot/netboot.tar.gz.

Nos desplazamos al directorio /srv/tftp/, descargamos la imagen y la descomprimimos:

$ wget http://ftp.debian.org/debian/dists/bullseye/main/installer-amd64/current/images/netboot/netboot.tar.gz
$ tar -zxf netboot.tar.gz && rm netboot.tar.gz

Tras este paso, el servidor ya está ofreciendo la imagen de debian a la red.

Reglas nftables

dado que el cliente solo está conectado al servidor, no tiene ninguna conexión a internet. Por lo que el servidor, además, tiene que hacer SNAT. Para ello vamos a activar el bit de forwarding y a aplicar las siguientes reglas de nftables:

$ nft add table nat
$ nft add chain nat postrouting { type nat hook postrouting priority 100 \; }
$ nft add rule ip nat postrouting oifname "eth0" ip saddr 192.168.100.0/24 counter masquerade
$ nft list ruleset > /etc/nftables.conf

Si la configuración no ha persistido tras un reinicio, podemos recuperarla con:

$ nft -f /etc/nftables.conf

Fichero Preseed

Para añadir el fichero preseed, tenemos dos opciones. Añadirlo a los ficheros que se están distribuyendo a través de PXE, o utilizar un servidor apache, realizándose de la misma manera que en el paso anterior.

Para utilizar el fichero preseed.cfg modificamos el fichero txt.cfg para que utilice el que estamos ofreciendo en el servidor apache:

label install
	menu label ^Install
	kernel debian-installer/amd64/linux
	append vga=788 initrd=debian-installer/amd64/initrd.gz --- quiet 
label unattended-gnome
        menu label ^Instalacion Debian Desatendida Preseed
        kernel debian-installer/amd64/linux
        append vga=788 initrd=debian-installer/amd64/initrd.gz preseed/url=192.168.100.5/preseed.txt locale=es_ES console-setup/ask_detect=false keyboard-configuration/xkb-keymap=e>

Lado del cliente

La instalación desde el lado del cliente es muy similar al paso anterior. Antes de empezar, hay que añadirle una tarjeta de red que esté en la red del DHCP, y hacer que sea una opción de arranque. Una vez hecho esto, el cliente iniciará la imagen en red, y desde ahí, podemos seguir los pasos que ya sabemos para utilizar el fichero preseed.cfg