Download GENERACIÓN DINÁMICA DE PÁGINAS

CLIENTE/SERVIDOR
EN INTERNET
Programación: Clientes Delgados
Dr. Víctor Jesús Sosa Sosa
[email protected]
GENERACIÓN DINÁMICA DE PÁGINAS
CGI (Common Gateway Interface)
Módulos compilados: Servlets, ISAPI (Internet
Information Server API), NSAPI (Netscape Server API)
Páginas con scripts de servidor: ColdFusion, PHP
(Hypertext Preprocesor), ASP (Active Server Pages),
JSP (Java Server Pages)
Cliente/Servidor en 3 Planos Estilo Web
DBMS
Visualizador
Web
HTML y
formas
HTTP
HTTP
TCP/IP
de Internet
3
Cliente Web
Documentos
HTML
CGI
Aplic.
Aplic.
Aplic.
Servidor Web
Monitores
De TP
Plano 3
Plano 2
Plano 1
Lotus
-otes
FORMAS
• Introducidas en HTML 2, ahora estandar en todos los
visualizadores (browser)
• Diseñadas para la Interacción entre Usuario y Servidor
HTML 1.0
Datos de la Forma
HTML + Formas
Browser
Servidor
JavaScript
VBScript
Página -ueva
Asistentes
Plugins ActiveX
Java
• Una forma es llenada en el browser y emitida al servidor para
que sea procesada por ejemplo por un script CGI.
• En general, los formularios incluyen un botón que, al ser
pulsado por el usuario, permite enviar los datos del formulario al
servidor Web para su procesamiento.
• Existen diferentes tecnologías para procesar formularios, las
cuales permiten la generación dinámica de contenido HTML a
partir de los datos de entrada mediante la ejecución de lógica de
trabajo.
CLIENTE/SERVIDOR
EN INTERNET
Programación CGIs
Dr. Víctor Jesús Sosa Sosa
[email protected]
CGI: Common Gateway Interface
Una de las formas más comunes de crear
páginas dinámicas Web es usando CGI, la
Interfaz de Pasarela Común (Common Gateway
Interface).
Usando programas CGI, el servidor puede
interactuar con aplicaciones para realizar
consultas en bases de datos, búsqueda de
documentos y procesamiento de solicitudes,
entre otras.
CGI: Programación
Normalmente, un servidor Web responde a
peticiones de documentos referenciados por
un URL.
Ocasionalmente, el cliente Web envía un
URL al servidor Web que apunta no a un
documento Web sino a una aplicación.
En este caso, el servidor activa la aplicación
la cual responde a la petición del cliente.
CGI: Programación
• Un aspecto clave en la programación CGI es
la incorporación de formas interactivas en
HTML 2.0
• Las formas colectan datos del cliente,
enviando ésta información a través del URL.
• La forma requiere del servidor que realice
una acción específica (programa CG I).
CGI: Programación
• La información producida por el CGI es
redirigida hacia el cliente como una página Web.
• El programa CGI es una aplicación desarrollada
en un lenguaje que pueda tener acceso a las
variables de ambiente del sistem a operativo.
• PERL se ha convertido en el lenguaje
predominante para escribir programas CGI.
CGI Scripts
• Las formas que se someten hacia un servidor, usualmente son procesadas
por scripts CGI corriendo en el servidor.
• Los scripts CGI pueden ser llamados directamente mediante el URL, sin
necesidad de una forma.
• Los scripts CGI peden estar hechos en cualquier lenguaje.
• Los scripts CGI pueden ser invocados por el servidor basado en algún
patrón de nombre de ruta (usualmente /cgi-bin/script).
Paso de Información a los CGIs
• Un Script es invocado desde su URL, pero alguna información adicional
pudiera haber sido agregada al URL.
• La información adicional pudiera estar en una variable de ambiente
(QUERY_STRING) o (si no se guardo en esa variable) venir de la entrada de
datos estándar.
• La información está en forma nombre/valor: nombre=valor&nombre=valor...
• La cadena de información tiene que pasar por un parser para extraer cada
valor (librerías en C, Perl, Java, Tcl, existen para hacer este trabajo, no hacerlo
otra vez).
Un Escenario Cliente/Servidor con CGI
Visualizador Web
Variables
de Entorno
Servidor Web
1
Submit
Envío
2
Método POST
4
3
Entorno de
Escritura
5 Ejecución
6
Entorno de Lectura
7
10
Regresa un
Archivo HTML
Cliente
Entrada Estandar
8
9 Salida Estandar
Servidor
CGI: Funcionamiento
1)
2)
3)
4)
5)
El cliente acumula datos de la forma HTML y los
prepara para su uso en la aplicación enviándolos
hacia el servidor en el URL usando el protocolo HTTP.
El servidor lee el URL que acompaña a la petición,
determina la aplicación que debe ejecutar y entonces
la activa.
El servidor pasa la información del URL a la
aplicación.
El programa CGI procesa los datos de la forma y
prepara la respuesta. Generalmente, la respuesta se
formatea como un documento HTML, de acuerdo al
protocolo HTTP.
El programa CGI pasa la respuesta al servidor quien la
redirige hacia el cliente.
CGI: Obtención de Datos del
Servidor
• Los datos se pasan al servidor Web de
varias formas:
Como
Como
argumentos en la línea de comandos.
variables de entorno del sistema
operativo.
Como entrada de datos estándar a un
programa.
La
mayoría
de
los
lenguajes
de
programación trabajan con los datos que se
pasan en la línea de comandos y la entrada
estándar.
Argumentos en la Línea de Comandos
• Los argumentos en la línea de comandos
son parámetros que usan los programas a
través de mecanismos propios del
lenguaje:
public void static main(String[]argv) en Java
Void main(int argc,char *argv[]) en C.
• Las consultas HTTP ISINDEX indican que
los datos se pasan como argumentos de
la línea de comandos.
CGI: Ejemplo
• El siguiente programa usa la línea de
comandos para recibir los parámetros de
la aplicación.
• El programa ejecutable Echo.exe puede
residir en el directorio /cgibin/ para
ejecutarse como programa CGI.
CGI: Ejemplo
// Echo.java
public class SysProps
{
public static void main(String[] args)
{
String argv;
if (args.length > 0)
argv = args[0];
else
argv = new String("CGI!");
System.out.println("Content-Type: text/html\n\n");
System.out.println("<HTML><BODY>");
System.out.println("<H1>”+argv+"</H1>");
System.out.println("</BODY></HTML>");
}
Este programa puede producir el texto HTML siguiente:
}
Content-Type: text/html
<HTML><BODY><H1>Hola!</H1></BODY></HTML>
CGI: Ejemplo
• El programa se activa con el siguiente URL en el
lado del cliente (browser):
http://www.miservidor.com/cgi-bin/Echo.exe?Hola!
• El directorio cgi-bin/ puede ser subdirectorio de
htdocs en el servidor: Apache (para ambos Unix
y Windows).
CGI: Ejemplo
• El programa Echo.exe también puede
activarse usando telnet dando la siguiente línea:
telnet www.miservidor.com 80
• Al responder telnet (frecuentemente, no redirige
la entrada del teclado hacia la pantalla), se
envía la petición HTTP directamente:
GET /cgi-bin/Echo.exe?Hola! HTTP/1.1 crlfcrlf
• Telnet mostrará el texto HTML generado por el
programa.
CGI: Variables de entorno
La forma de comunicación más común es
mediante las variables de entorno del sistema
operativo:
• Las variables son externas a la ejecución del
programa.
• El tamaño de los datos no pueden exceder los 40 Kb.
Las variables de entorno se pueden usar
independientemente de si la ejecución es
resultado de una petición ISINDEX, por el envío
de un formulario o por seguir un hiperenlace.
CGI: Variables de entorno
• Las variables de entorno se pueden usar
independientemente de si la ejecución es
resultado de una petición ISINDEX , por el
envío de un formulario o por seguir un
hiperenlace.
CGI: Variables de entorno
Variable
Descripción
CONTENT_LENGTH
Número de caracteres que se pasan a través de una
entrada estándar
CONTENT_TYPE
Tipo MIME asociado a los datos
GATEWAY_INTERFACE
Versión de la ción CG I del servidor
HTTP_*
Contenido de los cam pos recibidos en el encabezado
HTTP.
HTTP_ACCEPT
Contenido del campo HTTP_ACCEPT recibido en el
encabezado HTTP
PATH_INFO
Inform ación extra que se añade a la URL que
corresponde a un CGI
PATH_TRANSLATED
Ruta que el servidor Web extrae del URL
QUERY_STRING
Parte de la URL corresponde a la petición
CGI: Variables de entorno
Variable
Descripción
REMOTE_ADDR
Dirección IP del cliente
REMOTE_HOST
Dirección IP del servidor
REMOTE_IDENT
Nombre del cliente
REMOTE_USER
Nombre del asociado al cliente
REQUEST_METHOD
Método requerido por el cliente: GET, POST,
HEAD, etc.
SCRIPT_NAME
Ruta y nombre del CGI
SERVER_NAME
Nombre del servidor Web
SERVER_PROTOCOL
Nombre y versión del protocolo que se usa en la
petición
SERVER_SOFTWARE
Nombre y número de versión del servidor Web
Variables de Ambiente
• SERVER_SOFTWARE
• SERVER_NAME
• GATEWAY_INTERFACE
• SERVER_PROTOCOL
• SERVER_PORT
• REQUEST_METHOD
• HTTP_ACCEPT
• PATH_INFO
• PATH_TRANSLATED
• SCRIPT_NAME
• QUERY_STRING
• REMOTE_HOST
• REMOTE_ADDR
• REMOTE_USER
• REMOTE_IDENT
• AUTH_TYPE
• CONTENT_TYPE
• CONTENT_LENGTH
QUERY_STRING
contiene información
siguiente forma:
codificada
de
la
Los espacios se substituyen por signos +.
Los demás caracteres se pueden substituir
por %xx (dos dígitos hexadecimales).
Los datos de un formulario se codifican como
secuencia de pares name=value separados por
el signo &.
Paso de Variables de Entorno
El programa de comandos Echo.bat obtiene
la variable QUERY_STRING y la pasa en la
línea de comandos al programa Echo.exe :
@ECHO OFF
Echo.exe %QUERY_STRING%
• El programa Echo.bat se activa desde el
cliente:
HTTP://www.miservidor.com/cgi-bin/echo.bat
CGI: Formularios
• Los programas CGI procesan la
información
de
un
formulario
dependiendo del método usado GET o
POST.
• Si el formulario usa GET, los datos se
obtienen de QUERY_STRING.
• Si el formulario usa POST, los datos se
obtienen de la entrada estándar.
CGI: Formularios, Ejemplo
La forma FORM.HTML invoca a un CGI:
<HTML>
<BODY>
<H1>Hello Apache CGI!</H1>
<FORM METHOD="GET" ACTION="/cgi-bin/Echo.bat">
<INPUT TYPE="TEXTFIELD" NAME="USER"
VALUE="CGI Application">
<INPUT TYPE="SUBMIT" NAME="SEND" VALUE="OK">
</FORM>
</BODY>
</HTML>
CGI: Formularios, Ejemplo
• El URL http:/www.miservidor.com/cgibin/form.html
produce la invocación de la acción echo.bat
cuando se oprime el botón SEND (SUBMIT).
• El programa echo.exe se invoca con el valor
USER=CGI+Scripting&SEND=OK de la variable
QUERY_STRING.
• La página Web vista en el browser sería:
USER=CGI+Scripting&SEND=OK
CGI: Estado de la Sesión
• Durante la recopilación de datos de una
forma, el programa CGI no almacena
información intermedia ya que no ofrece
un estado persistente (stateless).
• La falta de persistencia se puede resolver
de dos formas:
Usando campos ocultos en la forma
Usando persistencia de objetos
Usando galletas (cookies)
Campos Ocultos
• El browser evita que los campos ocultos
se muestren en la forma, aunque pueden
usarse para almacenar información entre
transacciones.
<INPUT TYPE="hidden" NAME=".." VALUE="..">
• Usando concatenación de caracteres, el
atributo VALUE se usa para acumular los
datos obtenidos en la sesión.
CGI: Manteniendo el Estado
Estado
• Las sesiones en HTTP son sin estado.
• Las sesiones en HTTP solo duran desde la petición del visualizador a la
respuesta del servidor
• Para manejar cosas como tarjetas de compras, se necesita mantener alguna
información de la sesión o restaurarse de algun sitio
Cookies
• Las Cookies son identificadores con ningún significado en particular
• Son emitidas desde los servidores a los clientes
• Los clientes las almacenan por un periodo de tiempo
• En cada petición al mismo servidor, la cookie es incluida en la petición
• El servidor puede utilizar la cookie para restaurar el estado que colecto
recientemente, indexado por la cookie.
Campos Ocultos
•
•
•
•
•
•
Un campo en una forma HTML puede ser etiquetado como “oculto”
Este no aparecera en la forma
El valor del campo será asignado por el servidor
Cuando la forma es enviada, el campo será retornado al servidor
Información de estado puede ser ubicada en esos campos
Por privacidad, esto no debiera contener información personal.
Persistencia
• Un objeto se dice persistente cuando
extiende su duración más allá que la del
programa que lo originó.
• Los objetos persitentes requieren de un
medio de almacenamiento estable para
guardar su estado interno.
• Los objetos serializables más simples
son las cadenas de caracteres.
Persistencia
Para lograr persistencia, se necesita:
1.- Convertir la estructura y el contenido de
un objeto en memoria principal a una
forma secuencial de bytes que sea
apropiada para su almacenamiento o
trasmisión a través de una red
(serialización).
Persistencia
2. Crear un objeto idéntico al original a partir de su
forma serializada.
3. Un mecanismo para convertir a un objeto a o
desde su forma serializada, controlado ya sea
en forma automática o por programación.
• Java posee un conjunto de clases para
implementar persistencia:
ObjectOutputStream,
ObjectInputStream, Serializable,
Externalizable
Seguridad en CGIs: Servidor
• Temas importantes de seguridad en el Servidor
• El procesamiento de la forma es realizado con algún acceso al
sistema del servidor
• Lenguajes típicos utilizados son Perl, Shell, Tcl -lenguajes de
scripts que validan tipos débilmente, con capacidades de evaluación
• Los CGIs pueden ser atacados vía las Formas, o directamente.
Seguridad en CGIs: Cliente
• No hay mucho problema de seguridad en el Cliente
• Información muy limitada la que se transmite hacia el servidor
• El Identificador del Host del Cliente es conocido
• El Identificador del usuario en el Cliente es desconocido
• Si el cliente pasa información importante al servidor, la
seguridad en los servidores es el tema a preocuopar por parte del
cliente
• A los usuarios se les puede solicitar información importante, ej.
Numeros confidenciales - y pueden proveerlos -
/* ***************************************************************
Programa Espia
compilar en unix con: gcc -i espia.c -o espia.cgi
Este programa se da solo como ejemplo de programacion
de CGIs y el autor no se responsabiliza en modo alguno
por la utilizacion del mismo
*************************************************************** */
#include <stdlib.h>
void imprimeVariable( char *Nombre );
int main(){
/* *********************************** */
printf("Content-Type: text/html\n\n");
printf("<html><body bgcolor=#ffffff text=#ffffff>\n");
printf("<p align=center><table cellpadding=4 bgcolor=000000>\n");
printf("<tr><td color=000080 align=center>");
printf("<b>Variables del Sistema</b></td></tr>\n");
imprimeVariable("AUTH_TYPE");
imprimeVariable("CONTENT_LENGTH");
imprimeVariable("CONTENT_TYPE");
imprimeVariable("DOCUMENT_ROOT");
imprimeVariable("GATEWAY_INTERFACE");
imprimeVariable("HTTP_ACCEPT_LANGUAGE");
imprimeVariable("HTTP_COOKIE");
imprimeVariable("HTTP_REFERER");
imprimeVariable("HTTP_UA_COLOR");
imprimeVariable("HTTP_UA_CPU");
imprimeVariable("HTTP_UA_OS");
imprimeVariable("HTTP_UA_PIXELS");
imprimeVariable("HTTP_USER_ACCEPT");
imprimeVariable("HTTP_USER_AGENT");
imprimeVariable("HTTP_USER_CONNECTION");
imprimeVariable("PATH_INFO");
imprimeVariable("PATH_TRANSLATED");
imprimeVariable("QUERY_STRING");
imprimeVariable("REMOTE_ADDR");
imprimeVariable("REMOTE_HOST");
imprimeVariable("REMOTE_IDENT");
imprimeVariable("REQUEST_METHOD");
imprimeVariable("REMOTE_USER");
imprimeVariable("SCRIPT_FILE_NAME");
imprimeVariable("SCRIPT_NAME");
imprimeVariable("SERVER_NAME");
imprimeVariable("SERVER_SOFTWARE");
imprimeVariable("SERVER_PORT");
imprimeVariable("SERVER_PROTOCOL");
printf("</table>\n");
printf("</body></html>");
return( 0 );
void imprimeVariable( char *Nombre ){
/* *************************************
recibe el nombre de la variable y
la imprime formateada como celdas de
una tabla
************************************* */
printf("<tr>\n");
printf("<td bgcolor=\"#9999FF\" valign=top>%s</td>\n",Nombre);
printf("<td bgcolor=\"#DDDDFF\" valign=top><font color=#000000>");
/*
*********************
aqui toma la variable
y la imprime
*********************
*/
printf("%s",getenv(Nombre));
printf("</td>\n");
printf("</tr>\n");
}
}
CGI: Desventajas
• Además de la falta de persistencia, otro
problema importante es que el servidor
Web corre como proceso separado.
• La falta de interacción impide a los
programas CGI obtener información
importante del servidor (p.ej. el CGI no
puede escribir en el archivo histórico
(log) del servidor).
CGI: Alternativas
• OpenMarket
(www.fastcgi.com)
ha
desarrollado FastCGI, un estándar
alternativo que permite crear un sólo
proceso persistente por cada petición.
• Sin embargo, no reduce la proliferación
de
procesos
durante
peticiones
concurrentes.
• Tampoco mejora la interacción servidor ni
es suficientemente portable.
Alternativas CGI: PERL
• mod_perl es un módulo del servidor
Apache que mejora el rendimiento de
CGI.
• El programa demonio httpd contiene un
intérprete de Perl que ofrece acceso total
a la funcionalidad del servidor Apache.
• Los CGI son precompilados y ejecutados
en el servidor corriendo eficientemente.
CGI: Optimizaciones
CGI Básico
Servidor Web
1 proceso/petición
Proceso Principal
Petición1 a CGI A
Proc. Hijo de CGI A
Petición1 a CGI B
Proc. Hijo de CGI B
Petición1 a CGI C
Proc. Hijo de CGI C
Fast CGI
Servidor Web
1 proceso/CGI
Proceso Principal
Petición1 a CGI A
Petición1 a CGI B
Petición2 a CGI A
(único) Proc. Hijo de CGI A
Procesos persistentes.
(único) Proc. Hijo de CGI B
Alternativas CGI: Extensiones al
Servidor
• Varias empresas han desarrollado APIs
para extender sus servidores Web: ISAPI
de Microsoft y NSAPI de Netscape.
• Los APIs extienden la funcionalidad
básica del servidor para manejar tareas
relegadas a programas CGI.
• Las extensiones son difíciles de
desarrollar, mantener, portar y brindar
seguridad y confiabilidad (pueden hacer
caer al servidor).
Alternativas CGI: JavaScript en el
Servidor
• Netscape
ofrece
JavaScript
como
lenguaje interpretado de comandos en el
lado del servidor.
• JavaScript se inserta en páginas HTML
para generar contenido dinámico.
• Las páginas son precompiladas para
mejorar la eficiencia.
CGI: Optimizaciones
Uso de APIs del Servidor
NSAPI: Netscape/Sun
ISAPI: MS IIS
Módulo de Apache
Servidor Web
Proceso Principal
Petición1 extensión A
Petición1 extensión B
Extensión A
Extensiones parte del proc. servidor
Extensión B
Petición2 extensión A
Alternativas CGI: Java Servlets
• Java Servlets. Un servlet es una extensión
genérica (clases cargadas dinámicamente) que
extiende la funcionalidad del servidor.
• Cada servlet se maneja por un proceso ligero
(thread) dentro del servidor Web por lo que el
nivel de interacción es mayor que el conseguido
por CGI.
• Los servlets son más portables, escalables y
eficientes que la mayoría de las soluciones
anteriores.
CGI: Optimizaciones
Servidor Web
Servlets
Proceso Principal
Petición a servlet A
Petición servlet B
Petición servlet A
JVM
Trhead
Servlet A
Trhead
Trhead
Servlet: 1 trhead/petición
Servlet B
Servlets
• Usan clases e interfaces de 2 paquetes: javax.servlet (servlets genericos),
javax.servlet.http (añade funcionalidad particular http)
• No tienen método main() como en Java.
• Cada vez que el servidor pasa una petición a un servlet se invoca el método service(),
que habrá que reescribir (override).
• El método service() acepta 2 parámetros: objeto petición y objeto respuesta.
• Los servlets http, tienen ya redefinido el método service(), y llama a doXXX(), donde
XXX es el nombre de la orden que viene en la petición del servidor: doGet(), doPost(),
etc...
Servlets
Servidor
Web
Subclase HttpServlet
doGet()
Petición GET
Respuesta
service()
Petición POST
Respuesta
doPost()
Implementar en una subclase:
Servlets
• Ventajas Principales:
• Portabilidad. Usa las mismas llamadas (API), corre sobre Java.
• Potencia. Puede usar todo el API de java (excepto AWT), además
de comunicarse con otros componentes como RMI, CORBA, Java
Beans, Bases de Datos, etc.
• Eficiencia. Queda en la memoria del servidor como una única
instancia. Cada petición genera un trhead. Al estar persistente puede
mantener su estado con recursos externos (BD).
• Seguridad. Además de la seguridad que da la VM (gestión de
memoria, auscencia de punteros, excepciones), tiene un gestor de
seguridad “security manager” que puede evitar servlets
“malintencionados” o mal escritos que pueden dañar al servidor.
• Integración con el servidor. Puede cooperar con el servidor en
formas que los CGIs no pueden, como cambiar path de url, poner
líneas de log, comprobar autorización, asociar tipos MIME a los
objetos, incluso añadir usuarios y permisos al servidor.
Servlets
Código Fuente para el Ejemplo Hola Mundo
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException
{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<head>");
out.println("<title>Hello World!</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Hello World!</h1>");
out.println("</body>");
out.println("</html>");
}
}
Java Server Pages (JSP)
Tecnología que permite mezclar HTML regular y estático con contenidos
dinámicamente generados a partir de servlets
Se divide en dos partes: La parte estática de HTML y la parte dinámica
generada para JSP <% %>.
<html>
<head> <title> Bienvenido a nuestra tienda </title></head>
<body>
<h1> Bienvenido a nuestra tienda </h1>
<small> Si&eacute;ntase bienvenido,
<!-- el nombre del usuario será “usuario nuevo” para los visitantes de primera vez -->
<%= Utils.getNombreUsuarioDeCookie(petición) %>
. Para acceder a su configuración de cuenta, haga clic
<a href=“configurar-cuenta.html”> aqu&iacute;.</a></small>
<p>
El Html est&aacute;ndar para el resto de la p&aacute;gina de la tienda en Internet.
</body>
</html>
Alternativas CGI: Active Server Pages
• Microsoft ha desarrollado ASP para
insertar código (VBScript o JScript) en los
documentos HTML del servidor Web.
• El código se lee y ejecuta por el servidor
antes de que la página se envíe al cliente.
• ASP corre en IIS (v3.0) pero también en
otros
servidores
Web
con
Chili!
(www.chilisoft.com)
Ventajas de JSP
Comparado con:
• ASP. La parte dinámica está escrita en Java y no en VBScript
(transportable a más sistemas)
• PHP. Aunque es gratuito y tanto similar a ASP y a JSP, JSP cuenta con
una API más extensa (para redes, base de datos, objetos distribuidos, etc.)
• Servlets. JSP ahorra escribir muchos “println” , y divide más claramente
el trabajo de presentar contenido, con el trabajo de desarrollo de
aplicaciones.
• SSI. Server Side Inclusions. Solo orientado a aplicaciones sencillas. JSP
cuenta con más herramientas de apoyo
• JavaScript. Solo administra situaciones donde la información dinámica
esta en el lado del cliente. Con excepción de cookies, los datos de la
petición http no están disponibles para los procedimientos JavaScript
dellado del cliente. No accede a recursos del servidor (redes, BD, etc.)
CGI: Resumen de Optimizaciones
Optimizando CGIs
• Ejecutar un script CGI involucra crear un nuevo proceso
• Esto conlleva overheads
• Si el script puede correr dentro del servidor, este overhead es
removido
Ejemplos
• Active Server Pages - corren dentro del Internet Explorer
• Fast CGI
• Java servlets - corren dentro de Tomcat
• Modulos Apache
Costo/beneficio
• Menos costo de iniciación
• Pueden ser persistentes en el servidor
• Posiblemente podría estar un proceso de iniciación para
mantener la sesión
• Pero, tiene acceso a los interiores del servidor