Home » Guías » Swift Server Side con Vapor (I), instalación y primeros pasos
Vapor Swift I

Swift Server Side con Vapor (I), instalación y primeros pasos

Vapor, una de las soluciones más populares del desarrollo en Swift de lado servidor (o server-side). ¿Pero qué es eso de Swift de lado servidor? Ya hablamos de ello (y vimos un ejemplo básico) al hablar del primer framework HTTP que apareció: Kitura de IBM.

Por resumir, básicamente hacer una app de lado servidor es crear, mediante el lenguaje Swift en este caso, un proceso instalado en un servidor web que responderá a nuestras llamadas y creará respuestas dinámicas visibles a través de un navegador como código HTML. Este proceso es similar al que ocurre, por ejemplo, cuando llamamos en una web a una extensión PHP que no es más que código en este lenguaje, interpretado por el servidor y que devuelve una respuesta dinámica como HTML que podemos ver en nuestro navegador.

De esto, deriva lo que son las llamadas de tipo REST (o Representational State Transfer) que en este caso son algo más complejas. Basada en los mismos estándares web, una llamada de este tipo es una invocación de un proceso remoto en un servidor a través del envío de una petición en formato XML o JSON, que devuelve una respuesta en el mismo formato enviado. Al igual que nosotros podemos tener un formulario en una web y al pulsar en “Enviar” dicha información se envía y se obtiene una respuesta dinámica, podríamos decir que las llamadas REST son esto pero sin el uso de interfaces. Simplemente invocaciones remotas. La ventaja es que da igual el lenguaje o tecnología que usen cliente o servidor, mientras sigan el estándar, cualquier sistema puede comunicarse con otro, invocar sus procesos y obtener respuestas.

Vapor, instalación

Vapor es una de las soluciones de lado servidor basadas en Swift más populares, y es la primera de algunas que veremos en Apple Coding. Como hemos dicho, es un framework HTTP que permite usar código Swift a través de sus propias librerías (y uso de closures) para generar respuestas a peticiones que hagamos desde nuestra aplicación (o simplemente desde una navegador web, como veremos en los ejemplos de esta lección). Usar Vapor nos plantea grandes ventajas, la primera de ellas y más clara: no hay que usar más de un lenguaje de programación cuando necesitamos una implementación en servidor de nuestra app. Si queremos cualquier tipo de proceso en servidor, no será necesario programar en otros lenguajes sino que tanto el frontend (nuestra app) como el backend (el servidor) pueden usar el mismo lenguaje, lo cual es una ventaja operativa bastante clara.

La actual guía sigue el proceso en Linux Ubuntu 16.04, partiendo que se hayan realizado correctamente los pasos explicados en nuestra guía de instalación del lenguaje Swift 3 que podéis leer y seguir pulsando aquí. No obstante, es posible que este proceso también funcione en macOS desde modo terminal.

Lo primero que vamos a hacer es instalar las dependencias necesarias para que todo funcione. A saber, la librería de soporte de Unicode ( libicu-dev), las utilidades de binarios del sistema GNU ( binutils), el gestor de código Git ( git), las librerías de desarrollo que dan compatibilidad con el lenguaje de programación Python en su versión 2.7 ( libpython2.7-dev) y por último, la librería cURL de transferencia de archivos que consta de dos paquetes ( libcurl3 y curl). Con todo ello, abrimos un terminal y primero actualizamos la base de datos de versiones del sistema y luego instalamos estos paquetes.

Tras esto, toda la instalación la vamos a hacer con la utilidad Toolbox, que nos facilita bastante la tarea. Solo hay que ejecutar un par de scripts en remoto con el citado comando curl que nos permitirán, primero validar que nuestro sistema está correctamente configurado y es compatible, y segundo, proceder a la instalación de por sí.

Al ejecutar este comando tendremos que ver un simple comando que nos diga Compatible. Nada más. Eso significa que nuestro sistema está preparado así que ejecutamos el comando de instalación.

Podría darse el caso que viéramos algún mensaje que nos dijera que la instalación ha fallado, pero lo importante es que el último de todos los mensajes tras compilar todos los módulos de Vapor sea Vapor Toolbox v1.0.7 installed (nótese que 1.0.7 es la última que hay en el momento de instalación, este número puede cambiar obviamente).

Para comprobar que todo ha ido bien basta invocar la ayuda con vapor --help. Si vemos un resumen de los comandos disponibles, es que todo ha ido correcto. Y si queremos actualizar Vapor a cualquier nueva versión que haya aparecido más adelante, basta escribir vapor self update.

Hola mundo

Vapor funciona por creación de proyectos unidos a una instancia y posibles plantillas. La creación de instancias se asocia a un puerto y se realiza con el comando new, que nos permite crear dicha instancia en el raíz de nuestro servidor local que contestará al proyecto en Swift que esté asociado. Si no ponemos nada más, creará un proyecto en blanco con la plantilla por defecto, esperando que nosotros escribamos algo de código, aunque usará unos comandos por defecto para darnos un mensaje que nos muestre que todo ha ido bien si accedemos al raíz del servidor.

También podríamos tener la opción de poner la URL de un proyecto en git que nos permitiría instalar (mediante plantillas) algún software concreto pensado para Vapor en una URL concreta (la que digamos como raíz de nuestra instancia).

Primero vamos a crear un simple proyecto vacío para crear un simple droplet. Los droplets son los contenedores del servicio que permiten acceder a las funciones de Vapor. Registran el route hasta el servidor, inician el mismo, añaden alguna capa de middleware y mucho más. La estructura general de un programa Swift con Vapor siempre será:

La creación de los droplets normalmente se realiza en el fichero principal del proyecto, que en el caso de Swift Open Source hemos de recordar que siempre es main.swift para que este pueda ser ejecutable y no una librería.

Vamos a escribir para crear nuestro primer proyecto que vamos a llamar, en un alarde de originalidad, Hola. Así que nada más simple que irnos a una carpeta donde vayamos a trabajar (recordemos que yo siempre uso una carpeta Desarrollo o Developer) y dentro de ella creo mi instancia:

Tras darle a ENTER veremos una gota en ASCII que nos anuncia a Vapor, el web framework for Swift y luego nos dirá que nuestro proyecto está creado: Project “Hola” has been created. Type cd hola to enter the project directory. Enjoy!.

Dicho y hecho entramos al directorio y vemos que tiene la siguiente estructura de archivos:

El fichero que nos importa es, obviamente, main.swift que ahora mismo está situado en la ruta Hola/Sources/App. Dentro vemos que tenemos mucho más, pero que iremos viendo en posteriores versiones de esta guía.

En mi caso, con el propio navegador de ficheros de Ubuntu, me voy a esa carpeta y abro con Atom el fichero main.swift, donde vemos que él solo ha creado el siguiente contenido:

Vamos a probar a construir este mismo ejemplo para ver qué sucede. Lo único que tenemos que hacer es situarnos en nuestra carpeta Hola y desde ahí invocar la construcción del proyecto con Vapor:

Primero nos advertirá que no tiene una carpeta de paquetes a incluir con el mensaje No Packages folder, fetch may take a while… y luego veremos una pelotita que va y viene entre dos corchetes diciendo Fetching Dependencies. Cuando acabe, construirá el proyecto dando el mensaje Building Project con la pelotita moviéndose a un lado y a otro. Y sí… es muy lento, así que paciencia. Pero solo es la primera vez, las siguientes irá mucho más rápido.

Una vez ha terminado tendremos ambos mensajes [Done] en ambos procesos y de nuevo la vuelta a la línea de comandos. Ahora, vamos a arrancar el servidor.

Enseguida veremos tres mensajes:

Abrimos un navegador y accedemos a la URL http://localhost:8080. Veremos un claro mensaje con la gota de Vapor y un mensaje que nos dice: “It works”.

El motivo por el que vemos este mensaje es porque hemos creado un drop.get (haciendo un comando GET que básicamente se encarga de registrar peticiones http) pero no le hemos dado una ruta, por lo tanto lo ha asociado al raíz del servidor en el puerto que ha usado por defecto: el 8080. Una vez ahí, tenemos un closure que recibe un parámetro que nombramos como req, lugar donde vendría cualquier parámetro que se enviará en forma de formulario. Y luego hace un return de un try que llama al método make del componente view dentro del droplet que hemos creado. Este nos permite crear una vista estándar con Vapor cuyo nombre será la cadena “Welcome” (el primer parámetro) para luego enviarle un diccionario con el siguiente contenido ["message": drop.localization[req.lang, "welcome", "title"].

Vamos a cambiar ese mensaje y veremos que junto a la gota ahora nos aparecerá el mensaje que queramos poner. Pulsamos CTRL+C para cerrar el servidor, nos vamos al código fuente y lo dejamos de la siguiente forma.

Hemos quitado la instrucción drop.resource("posts", PostController()) porque, por ahora, no nos sirve para nada ya que crea un control de recursos asociado a la URL posts que por ahora no vamos a usar ni nos interesa. Volvemos a ejecutar el comando de construcción vapor build y de nuevo vapor run serve. Si accedemos a la página, veremos que ahora junto a la gota aparece el nuevo mensaje “Esto es Vapor” que hemos puesto. Así de simple.

Si por curiosidad, le pedimos que nos muestre el código fuente que ha generado, veremos el HTML dinámico que la llamada drop.view.make ha generado.

Añadamos ahora un nuevo get para crear una página diferente al raíz. Justo debajo de let drop = Droplet() ponemos lo siguiente:

Cerramos el servidor y volvemos a construir. Cuando acabe, arrancamos de nuevo vapor run serve. Ahora, gracias al get("hola") lo que hemos hecho es crear una página nueva dentro del servidor, que responderá en http://localhost:8080/hola. Si entramos veremos el mensaje en texto, que devolvemos con el return.

Como vemos, no es especialmente complejo. Todo se basa (por ahora) en que cuando creamos un get del objeto de tipo Droplet, entre paréntesis (como cadena) le enviamos el nombre de la página que queremos crear, y luego el closure asociado tendrá que devolver el contenido (también como cadena) que queramos que devuelva esa página.

Conclusiones

Ya hemos visto qué es Vapor, cómo funciona, cómo crear lo más sencillo, modificarlo y sobre todo construir y probar nuestro resultado. En próximas lecciones veremos mucho más, para ver cómo sacar partido a este interesante framework HTTP hecho en Swift. Probad y cualquier cosa, ya sabéis que podéis consultar en los comentarios. Un saludo y Good Apple Coding.

Acerca de Julio César Fernández

Analista, consultor y periodista tecnológico, desarrollador, empresario, productor audiovisual, actor de doblaje e ingeniero de vídeo y audio.

Otras recomendaciones

Prototipos Unit Testing TDD

Lecciones por prototipos (II): test unitarios (XCTest y TDD)

Una de las cosas que normalmente se perciben más complejas en el desarrollo en cualquier …