Salta el contingut

Administració de servidors d'aplicacions

Quan desenvolupem una aplicació web no n'hi ha prou amb programar-la. Necessitem un entorn capaç d'executar-la, gestionar les peticions dels clients, controlar la seguretat i administrar els recursos del sistema. Este entorn és el servidor d'aplicacions.

Un servidor d'aplicacions és el programari responsable d'executar la lògica de negoci d'una aplicació web. Actua com a intermediari entre el client (normalment un navegador web) i els recursos interns del sistema, com ara bases de dades, serveis externs o sistemes d'autenticació.

En l'ecosistema Java, alguns dels servidors més utilitzats són:

  • Apache Tomcat
  • WildFly
  • GlassFish
  • Payara Server

Nosaltres treballarem principalment amb Tomcat, ja que és lleuger, senzill d'administrar i adequat per a aplicacions basades en Servlets o Spring.

Què és un Servlet?

Un Servlet és una classe Java que s'executa dins d'un servidor d'aplicacions (com Apache Tomcat) i que permet gestionar peticions i respostes HTTP.

El seu funcionament bàsic és el següent:

  1. El client (navegador) envia una petició HTTP.
  2. El servidor d'aplicacions la rep i la redirigeix al Servlet corresponent.
  3. El Servlet processa la lògica de negoci.
  4. Genera una resposta HTTP (HTML, JSON, etc.).
  5. El servidor envia la resposta al client.

Els Servlets formen la base de moltes tecnologies Java web (JSP, Spring MVC, etc.).

Arquitectura i configuració bàsica

Quan instal·lem un servidor com Tomcat, este crea una estructura de directoris amb funcions molt concretes. Per exemple:

  • /bin: conté els scripts d'arrancada i parada.
  • /conf: inclou els fitxers de configuració.
  • /webapps: és el directori on es despleguen les aplicacions.
  • /logs: guarda els registres d'execució i errors.

Un dels fitxers més importants és server.xml, on es defineixen aspectes essencials com:

  • El port HTTP (habitualment el 8080).
  • La configuració de connectors.
  • La definició de serveis interns.

A més, el servidor pot configurar-se per gestionar:

  • Pools de connexions a bases de dades.
  • Límits de memòria de la JVM.
  • Recursos compartits entre aplicacions.

Esta configuració és crítica, ja que un mal ajust pot provocar problemes de rendiment o vulnerabilitats de seguretat.

Administració d'aplicacions web

Una vegada el servidor està operatiu, la tasca principal de l'administrador és gestionar les aplicacions que s'hi despleguen.

En entorns Java tradicionals, les aplicacions es distribueixen en format .war. Este fitxer arxiu conté tot el necessari per a executar l'aplicació dins del servidor. El desplegament pot fer-se simplement copiant el fitxer al directori /webapps o utilitzant la consola d'administració.

Les operacions habituals inclouen:

  • Desplegar una nova aplicació.
  • Actualitzar una versió existent.
  • Reiniciar una aplicació concreta.
  • Consultar els registres (logs per detectar errors.
  • Supervisar el consum de recursos.

Cal saber

En entorns més moderns, com Spring Boot, un framework MVC basat en Java és habitual generar un .jar executable que inclou un servidor embegut. En este cas, l'aplicació no necessita un servidor extern com Tomcat, ja que el porta incorporat.

Autenticació i seguretat

Un aspecte fonamental de qualsevol servidor d'aplicacions és el control d'accés. No tots els usuaris poden accedir als mateixos recursos.

Els servidors permeten diferents mecanismes d'autenticació:

  • Autenticació bàsica (Basic Auth).
  • Autenticació basada en formulari.
  • Integració amb LDAP o Active Directory.
  • Sistemes moderns basats en tokens (JWT).

Per organitzar la seguretat, es defineixen realms o dominis de seguretat, que agrupen usuaris i rols. Per exemple:

  • ADMIN → accés complet.
  • USER → accés restringit.

Este model permet aplicar el principi de mínim privilegi, concedint només els permisos estrictament necessaris.

Gestió de sessions

El protocol HTTP és sense estat (stateless), però les aplicacions web necessiten mantindre informació entre peticions. Això es resol mitjançant les sessions.

El servidor pot configurar:

  • El temps màxim d'inactivitat abans que la sessió expire.
  • El lloc on s'emmagatzema la sessió (memòria o base de dades).

Cooperació amb un servidor web

En entorns de producció és habitual separar el servidor web del servidor d'aplicacions.

El servidor web (com Nginx o Apache):

  • Serveix contingut estàtic.
  • Actua com a proxy invers.
  • Gestiona certificats TLS.
  • Redirigeix les peticions dinàmiques al servidor d'aplicacions.

Esta arquitectura millora el rendiment, la seguretat i l'escalabilitat.

Procés de desplegament

El desplegament d'una aplicació segueix una sèrie de fases clares:

  1. Compilació del projecte.
  2. Generació del paquet (.war o .jar).
  3. Transferència al servidor.
  4. Configuració de recursos (BD, variables d'entorn).
  5. Verificació mitjançant logs i proves HTTP.

En entorns professionals, el desplegament sol estar automatitzat mitjançant sistemes d'integració contínua (CI/CD), reduint errors humans i millorant la traçabilitat.

Seguretat del servidor

Finalment, l'administració del servidor implica garantir la seua seguretat. Algunes mesures essencials són:

  • Mantindre el servidor actualitzat.
  • Deshabilitar serveis i ports innecessaris.
  • Forçar connexions HTTPS.
  • Revisar registres d'accés i errors.
  • No exposar consoles d'administració en producció.
  • Externalitzar configuracions sensibles.

La seguretat no és una acció puntual, sinó un procés continu.

Guia d'instal·lació i desplegament d'aplicacions en Tomcat

En la següent guia instal·larem i desplegarem una aplicació senzilla en Tomcat 11 i OpenJDK 21.

Els passos bàsics seran:

  1. Instal·lar JDK.
  2. instal·lar Tomcat (binari) a /opt/tomcat.
  3. Crear + compilar + empaquetar + desplegar api-rest.war.
  4. Fer totes les proves REST (curl) i comprovacions (logs, permisos)

1. Instal·lar Java (JDK)

Instal·la el JDK executant les ordres següents:

sudo apt update
sudo apt install -y openjdk-21-jdk
````

Comprova la versió instal·lada:

```bash
java -version
javac -version

Hauria d’eixir una resposta semblant a:

openjdk version "21.0.10" 2026-01-20
OpenJDK Runtime Environment (build 21.0.10+7-Ubuntu-124.04)
OpenJDK 64-Bit Server VM (build 21.0.10+7-Ubuntu-124.04, mixed mode, sharing)

Configurar la variable d’entorn JAVA_HOME

Tomcat necessita conéixer la ubicació del JDK. Per això, cal definir la variable d’entorn JAVA_HOME.

Obtín la ruta del binari java amb:

readlink -f $(which java)

El sistema mostrarà una ruta semblant a:

/usr/lib/jvm/java-21-openjdk-amd64/bin/java

El valor correcte de JAVA_HOME és el directori arrel del JDK (sense /bin/java):

/usr/lib/jvm/java-21-openjdk-amd64

Edita el fitxer de configuració del terminal:

nano ~/.bashrc

El fiter ~/.bashrc

El fitxer ~/.bashrc és un script de configuració del terminal Bash que s’executa automàticament cada vegada que s’obri una nova sessió de terminal en mode interactiu.

Afig al final del fitxer (adapta la ruta si és diferent en el teu sistema):

export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH

Variable d’entorn PATH

La variable d’entorn PATH conté una llista de directoris on el sistema busca els executables quan escrius una ordre en el terminal.

Quan executes una comanda com java, el sistema recorre els directoris definits en PATH fins que troba un fitxer executable amb eixe nom.

En afegir $JAVA_HOME/bin a PATH, estem indicant al sistema que també busque les ordres de Java en el directori del JDK, de manera que puguem executar java i javac des de qualsevol ubicació del sistema.

Aplica els canvis executant:

source ~/.bashrc
echo $JAVA_HOME

El sistema hauria de mostrar:

/usr/lib/jvm/java-21-openjdk-amd64

En este pas hem instal·lat el JDK d’OpenJDK 21, hem verificat que la instal·lació funciona correctament mitjançant les ordres java -version i javac -version, i hem configurat la variable d’entorn JAVA_HOME perquè el sistema i aplicacions com Tomcat puguen localitzar l’entorn d’execució de Java. Finalment, hem aplicat els canvis en el fitxer ~/.bashrc i hem comprovat que la variable està definida correctament.

2. Instal·lar Tomcat

Accedeix al directori /opt, que és una ubicació habitual per a instal·lar programari addicional del sistema:

cd /opt

Descarrega el fitxer core tar.gz de Tomcat 11 (adapta la versió segons la disponible). Pots obtindre l’enllaç actualitzat des de:

https://tomcat.apache.org/download-11.cgi

sudo wget -O tomcat.tar.gz "https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.0-MXX/bin/apache-tomcat-11.0.0-MXX.tar.gz"

Descomprimeix el fitxer, elimina el fitxer descarregat i canvia el nom del directori a tomcat:

sudo tar -xzf tomcat.tar.gz
sudo rm -f tomcat.tar.gz
sudo mv apache-tomcat-11.0.0-MXX tomcat

Si el directori generat té un altre nom (per exemple, una versió diferent), substitueix-lo en l’ordre anterior.

Configurar permisos

Dona permisos d’execució als scripts del directori bin:

sudo chmod +x /opt/tomcat/bin/*.sh

Crea un usuari de servei específic per a Tomcat (pràctica recomanada en entorns de producció):

id tomcat || sudo useradd -r -m -U -d /opt/tomcat -s /bin/false tomcat
sudo chown -R tomcat:tomcat /opt/tomcat

Permet lectura als altres usuaris (per exemple, per poder compilar contra servlet-api.jar), però sense concedir permisos d’escriptura:

sudo chmod o+rx /opt
sudo chmod -R o+rX /opt/tomcat

Arrancar i comprovar el servidor

Inicia Tomcat com a usuari tomcat:

sudo -u tomcat /opt/tomcat/bin/startup.sh

Obri el navegador i comprova que el servidor està funcionant:

http://localhost:8080

Comprova la versió instal·lada:

/opt/tomcat/bin/catalina.sh version

Consulta els logs en cas d’error:

tail -n 80 /opt/tomcat/logs/catalina.out

Per a aturar el servidor:

sudo -u tomcat /opt/tomcat/bin/shutdown.sh

Tomcat encara no és un servei del sistema

En este punt, Tomcat s’està executant manualment mitjançant els scripts startup.sh i shutdown.sh. Això significa que:

  • No s’iniciarà automàticament quan es reinicie el sistema.
  • No es pot gestionar amb systemctl.
  • No disposa de supervisió automàtica en cas d’error.

En entorns de producció és recomanable configurar Tomcat com a servei systemd, de manera que el sistema operatiu el gestione automàticament.

En este pas hem instal·lat Apache Tomcat en el directori /opt, hem configurat correctament els permisos dels scripts i del directori d’instal·lació, i hem creat un usuari de servei específic per millorar la seguretat. Finalment, hem iniciat el servidor, hem verificat que respon en http://localhost:8080 i hem comprovat la versió i els logs per assegurar-nos que el funcionament és correcte.

3. Crear i compilar l'aplicació

En este punt pots descarregar l'aplicació API Rest des de assets/api-rest.war o seguir els passos per a crear-la i compilar-la.

Crear l'estructura de directoris

Crea l'estructura bàsica del projecte:

mkdir -p ~/projectes/api-rest/src/main/java/com/exemple/api
mkdir -p ~/projectes/api-rest/web/WEB-INF/classes
mkdir -p ~/projectes/api-rest/web/WEB-INF/lib

Estata estructura segueix el model estàndard d'una aplicació web Java:

  • src/main/java → codi font
  • WEB-INF/classes → classes compilades
  • WEB-INF/lib → dependències
  • WEB-INF/web.xml → descriptor de desplegament

Crear un web.xml mínim (Jakarta / Servlet 6.0)

Crea el fitxer:

nano ~/projectes/api-rest/web/WEB-INF/web.xml

Enganxa el contingut següent:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">
</web-app>

Este descriptor defineix l'aplicació com a aplicació Jakarta EE compatible amb Servlet 6.0.

Crear el servlet REST (/api/users/*)

Crea el fitxer:

nano ~/projectes/api-rest/src/main/java/com/exemple/api/UsersApi.java

Enganxa el codi del servlet proporcionat en el material de la pràctica.

Este servlet implementa una API REST bàsica amb suport per a:

  • GET → consultar usuaris
  • POST → crear usuari
  • PUT → actualitzar usuari
  • DELETE → eliminar usuari

La persistència és en memòria mitjançant un ConcurrentHashMap, per tant, les dades es perdran en reiniciar el servidor.

Compilar i empaquetar el WAR (sense Maven)

Compilar contra la Servlet API de Tomcat

Situa't en el directori del projecte:

cd ~/projectes/api-rest

Compila utilitzant el servlet-api.jar inclòs en Tomcat:

javac \
  -cp /opt/tomcat/lib/servlet-api.jar \
  -d web/WEB-INF/classes \
  $(find src/main/java -name "*.java")

Comprova que s'han generat els fitxers .class:

find web/WEB-INF/classes -type f | head
Crear el fitxer WAR

Accedix al directori web:

cd ~/projectes/api-rest/web

Genera el fitxer WAR:

jar -cvf ../api-rest.war .
ls -l ../api-rest.war

El fitxer api-rest.war és l'arxiu desplegable que conté l'aplicació web completa.

4. Desplegar en Tomcat

Copia el fitxer al directori webapps de Tomcat:

sudo cp ~/projectes/api-rest/api-rest.war /opt/tomcat/webapps/
sudo chown tomcat:tomcat /opt/tomcat/webapps/api-rest.war

Reinicia el servidor com a usuari tomcat:

sudo -u tomcat /opt/tomcat/bin/shutdown.sh
sudo -u tomcat /opt/tomcat/bin/startup.sh

Comprova que Tomcat ha descomprimit el WAR:

ls /opt/tomcat/webapps | grep api-rest

Hauries de veure:

  • api-rest.war
  • api-rest/

Consulta els registres (logs) en cas d'error:

tail -n 120 /opt/tomcat/logs/catalina.out

En este apartat hem creat manualment l'estructura d'una aplicació web Jakarta, hem compilat el codi contra la Servlet API de Tomcat, hem generat un fitxer WAR i l'hem desplegat en el servidor. Finalment, hem verificat que el desplegament s'ha realitzat correctament consultant el directori webapps i els logs del servidor.

5. Realitzar proves REST

Base URL: http://localhost:8080/api-rest

LIST (inicialment buit)

curl -i http://localhost:8080/api-rest/api/users

Resultat esperat:** 200 OK i resposta:

{"ok":true,"data":[]}

CREATE

curl -i -X POST http://localhost:8080/api-rest/api/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Anna","email":"anna@exemple.com"}'

Resultat esperat:

  • 201 Created
  • Capçalera Location: .../api/users/1

LIST (amb un usuari creat)

curl -i http://localhost:8080/api-rest/api/users

Resultat esperat: 200 OK i un array amb l'usuari amb id 1.

GET ONE

curl -i http://localhost:8080/api-rest/api/users/1

Resultat esperat: 200 OK i objecte JSON de l'usuari.

UPDATE parcial (només name)

curl -i -X PUT http://localhost:8080/api-rest/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{"name":"Anna Vidal"}'

Resultat esperat: 200 OK amb el camp name actualitzat.

DELETE

curl -i -X DELETE http://localhost:8080/api-rest/api/users/1

Resultat esperat: 204 No Content.

GET ONE (usuari inexistent)

curl -i http://localhost:8080/api-rest/api/users/1

Resultat esperat:

  • 404 Not Found
  • JSON d'error.

Validació d'error (POST mal format)

curl -i -X POST http://localhost:8080/api-rest/api/users \
  -H "Content-Type: application/json" \
  -d '{"name":"SenseEmail"}'

Resultat esperat: 400 Bad Request amb missatge d'error en format JSON.

Solució d'errors ràpid

Error 404 en totes les rutes

Comprova si Tomcat està arrancat:

ps aux | grep '[o]rg.apache.catalina.startup.Bootstrap'

Verifica que l'aplicació s'ha desplegat correctament:

ls /opt/tomcat/webapps | grep api-rest
Error 500 (error intern del servidor)

Consulta els registres:

tail -n 200 /opt/tomcat/logs/catalina.out
Errors de permisos

Comprova els permisos dels directoris clau:

ls -ld /opt/tomcat /opt/tomcat/webapps /opt/tomcat/logs /opt/tomcat/temp /opt/tomcat/work

Assegura't que el propietari és tomcat:tomcat i que té permisos adequats d'escriptura en els directoris necessaris.

En este pas hem validat el funcionament complet de l’API REST utilitzant l’eina curl, comprovant totes les operacions CRUD (GET, POST, PUT i DELETE) i les respostes HTTP corresponents. També hem verificat la gestió d’errors i codis d’estat com 400, 404 i 204. Finalment, hem revisat procediments bàsics de diagnòstic per a detectar problemes habituals de desplegament, com errors 404, errors interns 500 o incidències de permisos en Tomcat.