# Introducción a Google Cloud Platform
***Consola Cloud***
Ingresa a [console.cloud.google.com](https://console.cloud.google.com)
Explora la interfaz, identificando:
* El **menu de navegación** en la parte superior izquierda de la página.
* La barra de búsqueda en la parte superior central de la página.
* Menu de selección de proyectos entre el menu de navegación y la barra de búsqueda. **Presiona aquí para crear un nuevo proyecto para el curso.** Recuerda asociarlo a la Cuenta de facturación "Billing Account for Education" que tiene tus créditos de la clase.
**Proyectos**
En la página de bienvenida sale información del proyecto actual. Los proyectos organizan todos tus recursos en Google Cloud. Contiene usuarios, APis, facturación, autenticación, monitoreo, entre otros (explorar Dashboard).
Un proyecto tiene:
* **Nombre del proyecto**: No se necesita que sea único, se puede modificar y es elegido por el usuario.
* **ID del proyecto**: Identificador único globalmente, inmutable, elegido por el usuario.
* **Número de proyecto**: Identificador único globalmente, inmutable y asignado por GCP.
**Cloud Shell y SDK**
Cloud Shell es una instancia de VM con Debian como sistema operativo. Permite acceso desde navegador a los servicios de GCP por línea de comando y SDK. Posee 5GB de disco.
Abre Cloud Shell con el ícono en la parte superior derecha.
Algunos de los comandos que puedes utilizar son:
* gcloud CLI para GCP
* gsutil (Cloud Storage)
* bq (BigQuery)
Prueba el siguiente comando para que se listen las zonas de GCP.
```
$ gcloud compute zones list
```
**La primera vez que se utiliza cada servicio hay que habilitarlo (enable), se te preguntará cada primera vez y hay que aceptar.**
Prueba el siguiente comando para listar el nombre de la cuenta activa.
```
$ gcloud auth list
```
Prueba el siguiente comando para que listar el ID del proyecto.
```
$ gcloud config list project
```
Con gcloud se pueden levantar máquinas virtuales, instancias de bases de datos, clústeres de Kubernetes, trabajos y clusters para proseramiento de datos, entre otros. La documentación la puedes encontrar en el siguiente [Link](https://cloud.google.com/sdk/gcloud/reference)
Exploraremos *gsutil* y *bq* en otros laboratorios.
**Crear una Máquina Virtual VM**
Para familizarnos con GCP vamos a crear máquinas virtuales.
Primero vamos a dejar una zona por defecto con el siguiente comando en Cloud Shell:
```
gcloud config set compute/zone us-central1-b
```
Luego, para crear una VM por consola, en tu Cloud Shell ejecuta el siguiente comando, donde se deben reemplazar las palabras en mayúscula:
```
gcloud compute instances create VM_NAME \
[--image=IMAGE | --image-family=IMAGE_FAMILY] \
--image-project=IMAGE_PROJECT
--machine-type=MACHINE_TYPE
```
En particular puedes seleccionar la images de la lista que aparezca cuando ejecutas, como por ejemplo *debian-11-bullseye-v20230814*
```
gcloud compute images list
```
Y el tipo de imagen de la lista que aparece cuando ejecutas, por ejemplo n1-standard-1:
```
gcloud compute machine-types list
```
Estas listas pueden filtrarse con el comando *grep*.
Por ejemplo:
```
gcloud compute instances create "mi-mv1" \
--machine-type "n1-standard-1" \
--image-project "debian-cloud" \
--image-family "debian-11" \
--subnet "default"
```
**Si no hay suficiente recursos en la zona que has seteado por defecto, prueba en otra zona.**
La VM se demorará como un minuto en estar disponible para su uso.
Crearemos una segunda VM, pero ahora por interfaz gráfica.
1. Selecciona **Menú de Navegación** > Click **Compute Engine** > **Instancias de VM**. También lo puedes buscar directamente en la barra de búsqueda.
3. Selecciona **CREATE INSTANCE**
4. En **Nombre**, pon el nombre de tu segunda VM, por ejemplo *mi-mv2*.
5. Deja lo que viene por defecto en **Region** y **Zona**.
Fíjate que a la derecha aparece la estimación mensual del costo de la máquina virutal que estas por crear, experimenta cambiando la serie y el tipo, fijándote en las características de la máquina para que veas como influye. La serie E2 y tipo de máquina e2-micro es ideal para probar sin gastar créditos.
5. Para *Disco de arranque** selecciona **Debian GNU/Linux 11 (Bullseye)**
6. En **Firewall** marca *Permitir tráficio HTTP*.
7. Pon el siguiente script en Opciones avanzadas ->Administración -> Automatización, Startup script
```bash
#! /bin/bash
apt update
apt -y install apache2
cat <<EOF > /var/www/html/index.html
<html><body><p>Primeros pasos en GCP.</p></body></html>
```
8. Deje la configuración restante con sus valores predeterminados y haga clic en **Create**.
Cuando la VM está lista verás un símbolo verde al lado del nombre de la VM.
En la interfaz fíjate en las VM creadas, mira la zona de creación, sus IP Internas y externas.
Ahora conéctate a una de ellas, seleccionar **SSH**. Una vez dentro has ping a la otra VM con el comando:
```
ping mi-mv1.[ZONA]
```
Reemplazando *[ZONA]* por la zona en que está creada la VM, por ejemplo us-central1-a.
Detén el comando con **Ctrl+C**.
En la segunda VM creamos con el script un servidor de apache. Por lo que falta comprobar su instalacción accediendo en tu navegador a la IP externa de la VM donde está el servidor apache, o con el comando *curl* desde la otra instancia.
**DETENGA AMBAS INSTANCIAS**
En todos los laboratorios tenga especial cuidado en detener los recursos asignados, pues estos consumen créditos que se deben cuidar para dejar para la evaluación final. SEA EXTREMADAMENTE CUIDADOSO CON ESTO.
Para esto selecciona la instancia y haga click en **STOP** en el menu superior **OPERATIONS**.
La documentación completa para la creación de máquinas virtuales en GCP la puedes encontrar en el siguiente [Link](https://cloud.google.com/compute/docs/instances/create-start-instance#view-images)
# Contenedores
En esta actividad exploraremos el uso de contenedores en GCP.
En GCP puedes usar contenedores en múltiples servicios:
En *Compute Engine* se pueden desplegar contenedores de manera fácil en las intancias de VM. *GKE* es Kubernetes directamente, una plataforma de orquestación de contenedores que hace fácil la administración y escalar múltiples instancias. Finalmente, Cloud Run es una solución serverless, donde los contenedores son como microservicios.
Para esta actividad, vamos a construir una imagen, la subiremos a Artifact Registry y la desplegaremos en los sevicios de GCP, en particular en *Compute Engine*.
En GCP guardaremos la imagen en *Artifact Registry* para poder accederla luego, esto no es necesario para imágenes que ya están en un repositorio público y que se quieran usar tal cual.
Dirígete a *Artifact Registry* luego de buscar el servicio en la barra de búsqueda. Habilítalo (Enable) si no está habilitado:
Presionando sobre el símbolo + crearemos un nuevo repositorio.
1. **Nombre** podremos "mi-repositorio".
2. **Formato** Docker
3. **Tipo** Estándar
4. **Tipo de Ubicación** Region
5. **Region** us-central1
El resto deja los valores por defecto y presiona **CREAR**.
Copia el path del repositorio (PATHREPO) pues se usará muchas veces, como se indica en la figura. Debería tener la siguiente forma: <ZONA>-docker.pkg.dev/<IDPROYECTO>/nombre_repositorio
Ahora abre la consola de *Cloud Shell*. Antes de subir (push) y rescatar (pull) imágenes de *Artifact Registry* hay que configurar Docker para usar *Cloud Shell gcloud CLI* y autenticar consultas para *Artifact Registry*. Esto se hace con el siguiente comando, de acuerdo a la ZONA elegida:
```
gcloud auth configure-docker \
us-central1-docker.pkg.dev
```
Presiona Y, si pregunta si deseas continuar.
```
export PATHREPO="us-central1-docker.pkg.dev/<ID_PROYECTO>/mi-repositorio"
```
Ahora prepararemos la imagen para subir. Para construir la imagen escribiremos un archivo llamado Dockerfile con el siguiente contenido:
```dockerfile
FROM python:latest
RUN apt-get update && apt-get install -y python3 python3-pip
RUN pip3 install jupyter
RUN pip3 install numpy
RUN pip3 install pandas
RUN pip3 install matplotlib
RUN pip3 install plotly
RUN pip3 install seaborn
RUN pip3 install scikit-learn
RUN useradd -ms /bin/bash jupyter
USER jupyter
WORKDIR /home/jupyter
EXPOSE 8888
ENTRYPOINT ["jupyter","notebook","--ip=*"]
```
Para construirla la imagen usaremos el siguiente comando:
```
docker build -t ${PATHREPO}/micontenedor:v1 .
```
Autoriza en caso de ser consultado por Cloud Shell. Esto tomará su tiempo, en la imagen se instalan varios paquetes de uso común para Data Science.
Para ver la imagen que construiste, mirar su tamaño, su identificador y cuando fue creado:
```
docker images
```
Ahora la enviamos al *Artifact Registry*:
```
docker push ${PATHREPO}/micontenedor:v1
```
En la consola de google vuelve al servicio *Artifact Registry* para observar por este medio que se subió la imagen. Ocupemos esta imagen para correrla en un contenedor.
Si hacemos click en el contenedor e imagen podemos ver detalles:
**Desplegar contenedores en GCP**
Para Google compute engine, podemos correrla en una nueva instancia de máquina virtual, se puede hacer por consola pero ocuparemos la consola gráfica.
Antes de crear la instancia vamos a crear una regla de firewall que se requiere para habilitar el puerto que ocupará la instancia. Lo podemos hacer por consola en Red de VPC > Firewall, presionando en CREAR REGLA DE FIREWALL.
Luego de presionar Create regla de Firewall y completa con el nombre que quieras, pero con el Target Tag "jupyter" que lo usaremos en la creación de la instancia. La acción es permitir (Allow) y la dirección del tráfico es Ingress.
Luego en Protocolos y puertos poner Protocolos y puertos especificados , el puerto TCP 8888 y luego Click CREAR.
Ahora, anda por el menú de navegación a Compute Engine > Instancias de VM. Luego Crear Nueva instancia.
En **Nombre** va un nombre, por ejemplo, minotebook, en **Region** mantén la misma que el repositorio de Artifact Registry.
Luego en la zona de **Contenedor** > Click en **IMPLEMENTAR CONTENEDOR**. Pondremos el path al repositorio con su nombre en **Imagen de contenedor** (con la versión ':v1' por ejemplo) y seleccionamos Ejecutar con privilegios. Luego presiona **SELECCIONAR** al final para volver a la configuración de la instancia.
Le permitiremos acceso a todas las APIs de Cloud para que tenga el acceso a descargar el contenedor. Finalmente pondremos "jupyter" en **Network tags** para que se agrege la regla de firewall creada anteriormente a esta instancia. Presiona en CREATE para crear la instancia. Estará lista en 1 minuto.
Para conectarnos debemos ver información que general Jupyter dentro de la instancia por lo que hacemos SSH a la instancia creada y con el comando siguiente sabremos como conectarnos por navegador dado que necesitamos un token entregado por el contenedor para la conexión:
```
docker logs nombre_contenedor_desplegado
```
Con "docker ps" podemos saber que nombre le puso al contenedor.
Deberías ver esta información:
La última línea nos indica que debemos poner en nuestro navegador para conectarnos. Sin embargo, debemos reemplazar 127.0.0.0.1 por la IP externa de la instancia (ya sabes como buscarla). Deberías obtener algo como esto:
**NO OLVIDE DETENER LA INSTANCIA DE VM LUEGO DE ESTE EJERCICIO. También debes eliminar la imagen de Artifact Registry pues sobre 0.5GB se cobra por el almacenamiento.**
Sign in with Wallet
Connect another wallet