Automatize deployment script

.gitignore

@@ -12,6 +12,7 @@ node_modules/
 # Local files
 terraform.tfvars
 ip
+ips
 elb_dns
 src.zip
 key.pem

README.md

@@ -14,7 +14,7 @@ Tanto para escalar horizontalmente como para agregar una instancia de Redis, cad
 ## Setup
 ### AWS
 - Con el [pack estudiantil de GitHub](https://education.github.com/pack), crear una cuenta estudiantil en [AWS](https://aws.amazon.com/).
-- Entrar en IAM y crear un usuario "Terraform" con el grupo de permisos necesarios (AmazonEC2FullAccess, AmazonElastiCacheFullAccess).
+- Entrar en IAM y crear un usuario "Terraform" con el grupo de permisos necesarios (AmazonEC2FullAccess, AmazonElastiCacheFullAccess, AmazonS3FullAccess).
     - Desde IAM, generar un par de credenciales (key/secret) para ese usuario.
 - (sugerido) Para facilitar el deployment, la propuesta es que creen un bucket en S3 en donde suban un zip con el código del servicio (`app.js`, `config.js`, `package.json` y `package-lock.json`), y luego cada instancia se encargará de bajarlo, descomprimirlo y ejecutarlo. Para esto entonces:
     - Ir a S3 y crear un bucket. Por simplicidad, recomiendo que el bucket acepte lecturas de cualquiera, pero no escrituras. Pueden habilitar el versionado de los objetos en el bucket si quieren, pero no es importante.
@@ -92,3 +92,59 @@ terraform validate
 # Lista los providers instalados. Para este tp, deben ser al menos "aws" y "template"
 terraform providers
 ```
+
+## Correr los servidores
+### TL;DR
+Existe el script `start.sh` en la raíz del proyecto para crear la infraestructura y correr los servidores correspondientes.
+
+> **IMPORTANTE:** Es necesario tener instalado el [`aws-cli`](https://docs.aws.amazon.com/es_es/cli/latest/userguide/cli-chap-welcome.html) y [configurado](https://docs.aws.amazon.com/es_es/cli/latest/userguide/cli-config-files.html) con las credenciales correspondientes, donde además [se utiliza un perfil](https://docs.aws.amazon.com/es_es/cli/latest/userguide/cli-multiple-profiles.html) llamado `terraform`. Además, en el mismo se utiliza el binario de `terraform`, asumiendo que el mismo se encuentra en `~`. Por último, tal como se explicó antes, se asume que existe un bucket de S3 llamado `tp-arquitecturas`, al cual tiene acceso dicho usuario.
+
+### Explicación
+Lo primero que hay que hacer es crear la infraestructura:
+```sh
+terraform apply -auto-approve
+```
+> **NOTA:** El flag `-auto-approve` involucra que no se pida la aprobación del plan. **Utilizar bajo su propia responsabilidad**.
+
+> **IMPORTANTE:** Cabe destacar que en el archivo `python.tf` se especifica un comando para copiar la IP con la que se creó la instancia de python a un archivo local. Allí mismo también hay un comando que copia dicha IP al archivo `config.js` de la app node.
+
+Una vez que la infraestructura está creada, es importante notar que la misma tiene corriendo el proceso node (Notar que se corre el archivo `node_user_data.sh` al levantar la infraestructura, que es quien se encarga de comenzar dicho proceso) pero no el proceso python. Es importante entonces iniciar el proceso python en el servidor correspondiente:
+```sh
+cd python && ./start
+```
+
+Además es importante también notar que el código que comenzó a correr node posee una URL inválida del servidor python. Es por ello que es importante volver a zippear la aplicación:
+```sh
+cd node
+./zip
+```
+
+Luego, el archivo `src.zip` resultante debe ser subido al bucket correspondiente (especificado tanto en el `variables.tf` como en el script `update` de la carpeta `node`). Esto se puede hacer a mano, o bien utilizando el `aws-cli`:
+```sh
+aws s3 cp src.zip s3://tp-arquitecturas/src.zip --profile terraform
+```
+> **NOTA:** Aquí se está utilizando el perfil `terraform` del `aws-cli`. Los mismos se pueden [definir fácilmente](https://docs.aws.amazon.com/es_es/cli/latest/userguide/cli-multiple-profiles.html).
+
+Luego, para que los cambios tomen efecto, hay que updatear el código del proceso node en su servidor. Para ello se puede obtener las IPs de las instancias de los nodos de node desde la consola de EC2 de AWS (bajo el nombre "IPv4 Public IP"), o bien programáticamente:
+```sh
+aws ec2 describe-instances --profile terraform --query "Reservations[*].Instances[*].PublicIpAddress" --filters "Name=tag-value,Values=tp_arqui_node_asg_instance" --output=text | tr '\t' '\n' > ips
+```
+
+Finalmente, con dichas IPs, se deben updatear todos los servidores node, bien llamando al script `update` a mano para cada IP, o bien:
+```sh
+while IFS='' read -r ip <&3 || [[ -n "$ip" ]]; do
+    ./update "$ip"
+done 3< ips
+```
+> **NOTA:** El `3` indica el file descriptor a utilizar para correr dicho loop, de forma de que no se interceda con el `stdin`. Para más información, [ver aquí](https://stackoverflow.com/questions/37168048/bash-command-runs-only-once-in-a-while-loop).
+
+### Verificación
+Una vez levantados los servidores, se puede verificar su correcto funcionamiento utilizando la URL que se encuentra dentro del archivo `elb_dns` de la carpeta `node` y pegándole:
+```sh
+curl http://<elb_dns_url>
+```
+
+Lo cual chequeará que la app node funciona. A su vez, si se quiere ver que la misma se puede comunicar con el servidor python es necesario utilizar:
+```sh
+curl http://<elb_dns_url>/remote
+```

node.tf

@@ -35,7 +35,7 @@ resource "aws_elb" "node_asg_elb" {
   }
 
   provisioner "local-exec" {
-    command = "echo ${aws_elb.node_asg_elb.dns_name} >> node/elb_dns"
+    command = "echo ${aws_elb.node_asg_elb.dns_name} > node/elb_dns"
   }
 }
 

node/remote

@@ -15,4 +15,5 @@ else
     COMMAND="${@:2}"
 fi
 
-ssh -i $DIR/../key.pem ec2-user@$IP -- $COMMAND
+# The -o StrictHostKeyChecking=no is to avoid asking for permission to add the $IP to the list of known hosts
+ssh -o StrictHostKeyChecking=no -i $DIR/../key.pem ec2-user@$IP -- $COMMAND

node/update

@@ -14,11 +14,12 @@ echo "using IP $IP..."
 
 $DIR/stop $IP
 
+# The -o for the unzip command overrides if there's any existing file
 $DIR/remote $IP "\
     echo 'Downloading updated src' && \
-    curl https://s3.amazonaws.com/tp-arqui-node-app-src/src.zip > src.zip && \
+    curl https://s3.amazonaws.com/tp-arquitecturas/src.zip > src.zip && \
     echo 'Unpacking src code' && \
-    unzip src.zip  && \
+    unzip -o src.zip  && \
     echo 'Installing dependencies' && \
     npm i"
 

node/update-all

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e
+
+DIR="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+IPS=`cat $DIR/ips`
+
+while IFS='' read -r ip <&3 || [[ -n "$ip" ]]; do
+    $DIR/update $ip
+done 3< ips

python.tf

@@ -13,6 +13,11 @@ resource "aws_instance" "python" {
     command = "echo ${aws_instance.python.public_ip} > python/ip"
   }
 
+  # Use the python app IP in node code
+  provisioner "local-exec" {
+    command = "sed -E \"s/(remoteBaseUri:)[^,]*,/\\1 'http:\\/\\/$(cat python/ip):3000',/\" node/config.js > node/temp.js && mv node/temp.js node/config.js"
+  }
+
   # Environment setup
   provisioner "remote-exec" {
     inline = [

python/remote

@@ -7,4 +7,5 @@ COMMAND=$@
 DIR="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 IP=`cat $DIR/ip`
 
-ssh -i $DIR/../key.pem ec2-user@$IP -- $COMMAND
+# The -o StrictHostKeyChecking=no is to avoid asking for permission to add the $IP to the list of known hosts
+ssh -o StrictHostKeyChecking=no -i $DIR/../key.pem ec2-user@$IP -- $COMMAND

start.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Create infrastructure. This also changes the python IP in the node app so that they can communicate
+echo "##### Applying terraform infrastructure #####"
+~/terraform apply -auto-approve
+
+# Start the python app that is not started in the terraform apply command
+echo "##### Starting python app #####"
+cd python && ./start
+
+cd ../node
+
+# Get node instances IPs with the AWS CLI. It returns a tab-separated string with the IPs, so we transform them to end-lines
+echo "##### Getting node instances IPs #####"
+aws ec2 describe-instances --profile terraform --query "Reservations[*].Instances[*].PublicIpAddress" --filters "Name=tag-value,Values=tp_arqui_node_asg_instance" --output=text | tr '\t' '\n' > ips
+
+# Zip the source code of the node apps with the correct python IP
+echo "##### Zipping node source code #####"
+./zip
+echo "##### Uploading node source code to S3 bucket #####"
+aws s3 cp src.zip s3://tp-arquitecturas/src.zip --profile terraform
+
+# Update the node instances code with the src code uploaded to S3
+while IFS='' read -r ip <&3 || [[ -n "$ip" ]]; do
+    echo "##### Updating node source code of instance with IP $ip #####"
+    ./update "$ip"
+done 3< ips
+
+cd ..

variables.tf

@@ -24,17 +24,17 @@ variable "private_key_location" {
 }
 
 variable "vpc_id" {
-  default = "vpc-7563400d"
+  default = "vpc-d7cec3ac"
 }
 
 variable "ami_id" {
-  default = "ami-1853ac65"
+  default = "ami-14c5486b"
 }
 
 variable "node_version" {
-  default = "8.11.2"
+  default = "8.11.1"
 }
 
 variable "src_location" {
-  default = "https://s3.amazonaws.com/tp-arqui-node-app-src/src.zip"
+  default = "https://s3.amazonaws.com/tp-arquitecturas/src.zip"
 }