martes, 6 de noviembre de 2018

Google Cloud Functions with Python

Viene de https://itnext.io/writing-google-cloud-functions-with-python-3-49ac2e5c8cb3


Hasta hace poco, Node.js 6 era la única opción para escribir funciones de Google Cloud. Eso ha cambiado ahora con la adición de Node.js 8 y los también se puede ejecutar de Python 3 disponibles en la versión beta pública.

Veamos cómo usar el entorno de Python al implementar una función HTTP que realiza la misma tarea que hace la demostración de Node.js 8 Cloud Functions. Usaremos la biblioteca de request y la API randomuser.me para generar un objeto JSON que representa esos datos sobre un solo usuario, luego agregaremos una clave adicional llamada generator ...

----------------------------------------------------------------------------------------
import flask
import requests

def getUserDetails(request):
  user = requests.get('https://randomuser.me/api/').json()
  user = user['results'][0]
  user['generator'] = 'google-cloud-function'

  return flask.jsonify(user)


----------------------------------------------------------------------------------------


Este código  incluyen:


  • El tiempo de ejecución de Python utiliza Python 3.7.0
  • Tus funciones tienen que estar dentro de en un archivo llamado main.py
  • El argumento de request de la función será un objeto de solicitud Flask.
  • La función debe devolver todo lo que se puede hacer en un objeto de respuesta de Flask utilizando make_response de Flask; en este caso, pasamos una cadena JSON
  • Las dependencias se especifican en requirements.txt, que se ve así para nuestro ejemplo (los números de versión también se pueden especificar, por ejemplo, request=2.19.1):



Al implementar esta función, tenemos que decirle a Google que use   Python 3. Para hacer esto, debemos asegurarnos de tener los últimos comandos de gcloud beta:

----------------------------------------------------------------------------------------
$ gcloud components update
$ gcloud components install beta



----------------------------------------------------------------------------------------

El despliegue es simple (tenemos que usar los comandos beta y explícitamente decir que queremos el usar Python):

----------------------------------------------------------------------------------------
$ gcloud beta functions deploy getUserDetails --runtime python37
--trigger-http --project



----------------------------------------------------------------------------------------

Donde es el ID de su proyecto de Google Cloud. La función se puede invocar simplemente  visitando su URL, que se verá así:

----------------------------------------------------------------------------------------
https://-.cloudfunctions.net/getUserDetails


----------------------------------------------------------------------------------------

y dependerán de la configuración de su proyecto de Google Cloud, y el comando gcloud mostrará la URL de invocación completa de su función al final de una respuesta correcta.

La salida se ve así:


Ejemplo de salida de la cloud function usando Python.


Salida de ejemplo de Google Cloud Function usando Python:



Y eso es todo lo que hay que hacer!

Si quieres usar o estudiar el código de este artículo: lo puso en GitHub. La documentación de Google para el runtime de Python Cloud Functions se puede leer aquí.

viernes, 26 de octubre de 2018

Empieza usando Terraform en Google cloud

HashiCorp Terraform es una potente herramienta de automatización de infraestructura de open source para aprovisionar y administrar la infraestructura como código.

Google ha estado colaborando con HashiCorp desde 2013 para ayudar a los clientes que usan Terraform y otras herramientas de HashiCorp a hacer un uso óptimo de los servicios y características de Google Cloud Platform (GCP).

A medida que Terraform y GCP crecieron en popularidad, se continuado integrando las herramientas con mayor profundidad para facilitar la experiencia del desarrollador. Pero si bien hay una larga y creciente lista de recursos de proveedores de Terraform GCP, comenzar con Terraform en GCP puede necesita un poco de formación:

  •     Instalar Terraform
  •     Configurar una cuenta de servicio GCP
  •     Copie una configuración que (con suerte) funcionó de la documentación.
Una forma nueva y fácil de evitar este proceso manual es utilizando Google Cloud Shell. Con Cloud Shell, obtiene acceso de la línea de comandos a sus recursos de la nube directamente desde su navegador, por lo que puede administrar proyectos y recursos fácilmente sin tener que instalar ninguna herramienta en su sistema.
Además, las herramientas de línea de comandos como Terraform y otras utilidades se autentican automáticamente, por lo que puede usarlas sin necesidad de configuración.





Toma nota: hay varios ejemplos en la documentación del proveedor de GCP ahora tienen un botón "Abrir en Cloud Shell", que le permite iniciar configuraciones de uso de ejemplo de Terraform con un solo clic.

Haga clic en el botón para iniciar una sesión interactiva de Cloud Shell con el ejemplo cargado y Terraform listo para usar. De esta manera, puede utilizar configuraciones Terraform reales y de trabajo en Cloud Shell e iterar ideas antes de incorporarlas al flujo de trabajo de aprovisionamiento de infraestructura como código de su equipo.

open in cloud shell


En resumen, con esta nueva integración con Cloud Shell, aprender a usar los nuevos recursos de GCP en Terraform es más fácil que nunca:

Empiece a configura la infraestructura de forma instantánea como código con Terraform en GCP, no se requiere experiencia

Para comenzar con nuestro ejemplo de instancia de máquina virtual a continuación. Asegúrese de seguirnos en Twitter y de abrir un problema de GitHub si tiene alguna pregunta.

Para obtener más información sobre Terraform, visite: https://www.terraform.io


¿Está interesado en contar a otros tu historia de uso de HashiCorp o quizás cómo los productos de HashiCorp ayudaron con ese increíble proyecto que construyó? Haznos saber. Envíe su historia o idea a guestblogs@hashicorp.com.

martes, 23 de octubre de 2018

Nueva herramienta para el analisis de Firewall y logs de las redes.

En el momento que tenemos trafico en nuestra red, se necesita monitorizar el trafico, su tamaño y  cargas de trabajo en los sistemas, para garantizar que todas las conexiones establecidas tengan su autorización  y que todos los intentos de conexión no deseados se bloqueen correctamente. 

En Google cloud se acaba de mejorar la monitorización de seguridad de la red de Google Cloud Platform (GCP) y las capacidades forenses con la introducción del registro de reglas de firewall, que le permite rastrear todas las conexiones que se han permitido o denegado en sus instancias de VM, casi de en tiempo real.

Como parte de las  ofertas para telemetría de red, el registro de reglas de firewall le permite auditar, verificar y analizar los efectos de sus reglas de firewall. En otras palabras, puede validar que cada conexión establecida en su flujo de trabajo  coincida con las condiciones de sus reglas de firewall de acceso permitido; y de manera similar, se bloquea cualquier conexión que coincida con una regla de firewall de acceso denegado.


Además, los registros de firewall muestran registros de conexión permitidos o denegados cada cinco segundos, lo que le brinda visibilidad casi en tiempo real de los posibles riesgos de seguridad.



firewall_logs.png


Los registros de firewall capturan las conexiones de todos los firewalls aplicados a cada flujo de trabajo, incluyendo:

  • Permitir y denegar reglas de firewall 
  • Conexiones de entrada y salica. 
  • Conexiones desde dentro de una VPC y desde internet.

Los registros generados por este proceso producen registros que incluyen una variedad de puntos de datos, incluida la 5-tupla de la conexión, si la disposición fue PERMITIDA o NEGADA, y qué regla se aplicó en el momento del registro. También puede exportar de forma nativa estos datos a Stackdriver Logging o BigQuery. O, utilizando Cloud Pub / Sub, puede exportar estos registros a cualquier número de analíticas en tiempo real o plataformas SIEM.



Ajusta, analiza y depura la seguridad de tu red.


La disponibilidad del registro de reglas de firewall es útil para una amplia variedad de tareas de operaciones de seguridad de red:


    Depuración de la seguridad de la red: los registros del servidor de seguridad le permiten solucionar problemas de las conexiones de red, informándole casi en tiempo real si sus conexiones de 5-tupla estan permitidas o negadas, según el nombre de la regla del servidor de seguridad y las condiciones exactas.


    Análisis forense de seguridad de red: los registros de firewall le permiten investigar comportamientos de red sospechosos y no deseados, por ejemplo, un gran número de conexiones no autorizadas de fuentes específicas a las que se está bloqueando el acceso.


    Auditoría y cumplimiento de seguridad de la red: los registros de firewall también lo ayudan a garantizar el cumplimiento, al registrar cada conexión permitida y cualquier intento no autorizado bloqueado en cualquier momento. También marca y registra las instancias de VM que intentan iniciar conexiones de salida no autorizadas.


    Análisis de seguridad en tiempo real: con Cloud Pub / Sub API, puede exportar fácilmente sus registros a cualquier ecosistema SIEM que ya esté utilizando.


Para obtener más información acerca de los registros de reglas de firewall, incluyendo cómo comenzar y los precios, visite la documentación y la página del producto.


miércoles, 17 de octubre de 2018

Cloud NAT [Nuevo servicio en Google Cloud]

cloud_NAT.png 


En Google Cloud español nos hacemos eco de que  hace unos días, se anuncio la versión beta del servicio servicio Cloud NAT totalmente gestionado.
 

Los usos del "Cloud NAT"


Cuando coloca una aplicación detrás de una puerta de enlace NAT en el Cloud, puede acceder a Internet (para actualizaciones, parches, administración de configuración y más) de una manera controlada y eficiente, pero los recursos externos no pueden acceder directamente a esas instancias. Esto ayuda a mantener sus VPC de Google Cloud más aisladas y seguras.
Cloud NAT ofrece una serie de ventajas en comparación con otras ofertas de NAT:
  • Como una solución definida por software sin un proxy central administrado, Cloud NAT ofrece un diseño  que es altamente confiable, de alto rendimiento y escalable.
  • Cloud NAT es compatible con las máquinas virtuales (VM) de Google Compute Engine y con el motor de Google Kubernetes (contenedores).
  • La capacidad de configurar múltiples direcciones IP de NAT por puerta de enlace NAT le permite escalar según el tamaño de su red sin tener que agregar o administrar otra puerta de enlace NAT.
  • Los modos Manual y Automático para la asignación de IP NAT le permiten ajustar según sus requisitos específicos.En modo manual proporciona un control total al especificar IP, y en modo Automático permite que las IP de NAT se asignen y escalen automáticamente según el número de instancias.
  • Ajuste los valores de timeout del NAT.
  • NAT todas las subredes en una VPC para una región a través de una única puerta de enlace NAT, independientemente del número de instancias en esas subredes.
  • Alta disponibilidad regional incluso si una zona no está disponible.

Los primeros usuarios de Cloud NAT están implementando y presenta un correco funcionamiento dentro de sus implementaciones existentes de Google Cloud.


NAT  chokepoint, definido por software

Chokepoint-free.png

 
Cloud NAT es un servicio totalmente administrado, definido por software, no una solución basada en instancias o dispositivos. Esto difiere de las soluciones de proxy NAT tradicionales porque no hay proxies intermedios NAT en la ruta desde la instancia hasta el destino. En su lugar, a cada instancia se le asigna una IP NAT junto con una asignacion del rango de puerto asociado. Esta IP asignada y el rango de puertos está programado por nuestra pila de virtualización de red de Andrómeda en la instancia y luego la instancia lo utiliza para realizar NAT.

La implementación de Cloud NAT, es similar a nuestros cortafuegos, se distribuye sin ningún punto de estrangulamiento en la ruta entre su instancia interna y su destino externo. Este enfoque ofrece una mayor escalabilidad, rendimiento, rendimiento y disponibilidad para Cloud NAT.

Modos de asignación de IP NAT


Cuando se diseño el modelo de asignación de IP de Cloud NAT, por peticion de los clientes que apuntaban a  la capacidad de configurar las IP de NAT estáticas y especificadas manualmente es esencial para que puedan abrir firewalls para estas IP de NAT en los servidores externos. Tambien se puede  escalar automáticamente las IP de la nube como lo hacen nuestros balanceadores de carga.

Por eso se puede ofrecer dos opciones para la asignación de IP NAT:
  •     Podemos usar la asignación automática de direcciones IP mediante una puerta de enlace NAT: GCP asigna automáticamente las direcciones IP de NAT y las ajusta automáticamente en función del número de máquinas virtuales. Esta es la mejor manera de garantizar que haya suficientes IP disponibles para NAT. Tenga en cuenta que con este método, las IP de la lista blanca en el lado receptor se ajustan peor  porque algunas IP se liberan cuando ya no son necesarias.
  •     Configure una (s) IP (s) NAT específica (s) para ser utilizadas por una puerta de enlace NAT: En este caso, debe especificar manualmente una o más IP de NAT para que la puerta de enlace NAT las utilice. Estas direcciones IP deben ser reservadas y estáticas, y no se realiza una autoasignación de direcciones IP. Se prefiere este modo si necesita incluir en la lista blanca las direcciones IP de NAT en el lado receptor. Tenga en cuenta que si no hay suficientes IP NAT para realizar NAT para todas las instancias requeridas, entonces algunas de estas instancias no podrán usar NAT. Recibirá un mensaje de registro cuando se requieran más direcciones IP de NAT.

Creando una puerta de enlace NAT en su VPC


Para configurar una puerta de enlace NAT en su entorno. Echemos un vistazo a un ejemplo.

Digamos que tiene una red GCP que contiene tres subredes en dos regiones:
    us-este1
        subred 1 (10.240.0.0/16) y subred 2 (172.16.0.0/16)
          europa-oeste
                subred 3 (192.168.1.0/24)

Las máquinas virtuales en la subred 1 (10.240.0.0/16) y la subred 3 (192.168.1.0/24) no tienen direcciones IP externas, pero necesitan obtener actualizaciones periódicas de un servidor externo al 203.0.113.1. Las máquinas virtuales en la subred 2 (172.16.0.0/16) no necesitan obtener estas actualizaciones y no se les debe permitir conectarse a Internet en absoluto, incluso con NAT.

VMs in subnet.png
 
Para lograr esta configuración, primero configure una puerta de enlace NAT por región, por red:

   1. Configure NAT-GW-US-EAST para la subred 1 (10.240.0.0/16).

   2. Configure NAT-GW-EU para la subred 3 (192.168.1.0/24).

   3. Configure cada puerta de enlace NAT con la (s) subred (s) para la cual debe traducir el tráfico:

        subred 1 (10.240.0.0/16) para NAT-GW-US-EAST

        subred 3 (192.168.1.0/24) para NAT-GW-EU

   4. No configure NAT para la subred 2. Esto lo aísla de Internet, como lo requiere este ejemplo.

Para obtener información detallada sobre cómo configurar Cloud NAT, puede ver las configuraciones de Cloud NAT para Google Compute Engine y Google Kubernetes Engine aquí.

Cloud NAT para GKE

Puede usar Cloud NAT para los contenedores de Kubernetes de Google (GKE) configurando Cloud NAT a NAT-traducir todos los rangos en la subred.


GKE.png

Tanto los nodos como los pods pueden usar Cloud NAT. Si no desea que los Pods puedan usar NAT, puede crear una Política de red de clústeres para evitarlo.

En el ejemplo anterior, se permite que sus contenedores se traduzcan a NAT. Para habilitar NAT para todos los contenedores y el nodo GKE, debe elegir todos los rangos de IP de la subred 1 como candidatos de NAT. No es posible utilizar NAT solo para container1 o container2.

Precios y disponibilidad

Cloud NAT está disponible en todas las regiones de Google Cloud, y durante el período beta, lo ofrecemos de forma gratuita. Una vez que Cloud NAT está disponible en general (GA), cada puerta de enlace tiene el precio siguiente:
  •     A partir de $ 0.045 por hora de puerta de enlace NAT
  •     Cargos de procesamiento de datos NAT

Además, los costos de transferencia de salida para mover datos entre una instancia de GCP e Internet permanecen sin cambios. Para obtener más información, lea acerca de los precios de NAT de la nube aquí.

Prueba Cloud NAT

Hemos estado ocupados ofreciendo capacidades como Cloud NAT para hacer que sus cargas de trabajo y servicios de Google Cloud sean fáciles de implementar y administrar. Lea  la documentación en línea de Cloud NAT y comience con una implementación de muestra utilizando nuestro ejemplo de Cloud NAT. También nos encantaría recibir sus comentarios, puede contactar en gcp-networking@google.com.

miércoles, 10 de octubre de 2018

Nuevo video de introducción a Google cloud en nuestro canal on-line

Teneis un nuevo video de introducción  a la plataforma de google Cloud , y como poder crear una maquina con Windows Server y otra con Ubuntu, en el entrono de Google Cloud, ademas intalamos apache en la maquina Linux y nos concestamos via http.

Es un video de introduccion recomendado para aquellos que nunca han usado la plataforma cloud, con recomendaciones he indicaciones de como sonseguir creditos free.

Enjoy.


miércoles, 19 de septiembre de 2018

Crear tutoriales de Google Cloud Shell 2/2

Hoy os paso la segunda  de mis Bloggeros favoritos Romin Irani un traducción de su presentación de como crear tutoriales para Google Cloud Shell

A Romin Irani  le encanta escribir tutoriales, termina escribiéndolas como publicaciones de blog (bastante detalladas) y hace todo lo posible para no perder un paso y dar capturas de pantalla de qué esperar encontrar en el progreso.

Plan de tutorial

Antes de sumergirnos en los detalles de creación del tutorial, recordemos una cita.


    Ninguna batalla se ganó de acuerdo al plan, pero nunca se ganó batalla sin una - Dwight D. Eisenhower


No se puede  enfatizar lo suficiente la importancia de planificar tu tutorial. Incluso si nunca ha creado un tutorial paso a paso, agregue un conjunto aproximado de pasos. Por ej. Cada uno de los números a continuación podría ser un paso en el tutorial.



  1.     ¿De qué se trata este tutorial?
  2.     ¿Cuáles son los requisitos previos?
  3.     ¿Qué configuración tenemos que hacer antes de inspeccionar el código?
  4.     Navega por el código y explícalo
  5.     Instrucciones para compilar el código
  6.     Ejecutando el código
  7.     Algunos puntos para resumir los aprendizajes
  8.     Conclusión


Espero que entiendas la imagen. Lo que funciona para mí es poner los puntos anteriores como secciones y luego llenarlos de acuerdo con el texto, el código fuente, las instrucciones para construir / ejecutar, etc. Estas son solo mis recomendaciones, pero debe ir con su flujo y cómo le gustaría escribir el tutorial.




Crear el esquema


El tutorial que debe crear se incluirá en un único archivo de sintaxis  o marcacion Markdown (CommonMark). Vamos a llamar a este archivo tutorial.md. Se puede pensar conceptualmente que el tutorial tiene lo siguiente:



  •     Título
  •     Una o más secciones
  •     Cada sección puede tener múltiples subsecciones (o temas)


Un ejemplo de archivo tutorial.md se muestra a continuación:



  # Tutorial en Google Natural Language API .       
  ## API de lenguaje natural de Google (PASO 1)   
      … algún texto … .                                              
      ### Prerrequisitos                                               
  ## Creación de cuenta de servicio (PASO 2) .       
  ## Use npm para instalar dependencias (PASO 3) 
  ## Código fuente (PASO 4)                                    
  ## Ejecute la aplicación (PASO 5)                         
  ## Conclusión (PASO 6)                                        
  ### Próximos pasos: (PASO 7)                              



La sintaxis admite las etiquetas H1 (#), H2 (##) y H3 (###) para notificar el título del tutorial, los pasos en el tutorial y los pasos intermedios, respectivamente. Eso es todo al respecto. Solo puede haber una etiqueta de título (#) en todo el tutorial.


Detalles paso a paso

Ahora que tiene el esquema claro, todo lo que necesita hacer es completar los detalles en cada uno de los pasos y subpasos. Tenga en cuenta que las etiquetas de título, es decir, ## y ##, determinarán el título, es decir, la etiqueta de los pasos y lo que les sigue es lo que se mostrará en esa página de paso en particular en el tutorial.


Es obvio que podemos poner tanto texto como queramos. Pero, ¿cuáles son los otros elementos que admite? Los creadores de herramientas lo han pensado cuidadosamente y han presentado soporte inicial para múltiples elementos personalizados que mantendrán la experiencia del usuario en mente, es decir, facilitarán al lector hacer clic en ciertos puntos de la pantalla (iconos) al resaltarlos, abriendo archivos en el editor, etc.


Vamos a discutir algunos de estos elementos:


Bloque de código

Veamos un punto particular de mi completo archivo tutorial.md. Una parte del paso tutorial representado se muestra a continuación:





Ahora debería poder identificar fácilmente que consiste en:



  1.     Título punto a punto
  2.     Algún texto
  3.     Bloque de código




El fragmento de código para admitir eso se muestra a continuación:





   ## Service Account Creation                                      
First up, let’s create an environment variable to store your Project Id. Please use the code snippet below to set the `PROJECT_ID` variable as given below:
```bash
export PROJECT_ID=
```


El título para el paso es a través de la etiqueta H2 (##). El texto es estándar y la forma de incluir cualquier bloque de código es a través del elemento `` `bash ... ..` `` como se muestra arriba.

La mejor parte de esto es que se muestra como se muestra a continuación con un icono de Copiar en la esquina superior derecha. El usuario puede hacer clic en esto, que copia el comando en el portapapeles y puede pegarlo en la sesión de la terminal de Shell fácilmente. Estos detalles  hacen una gran diferencia.



    Nota: Puede tener tantos bloques de código en un paso como desee.

Trigger en archivo abierto


Este es un punto interesante que le ayuda a abrir el archivo directamente en el editor de Orion que está integrado en el espacio de trabajo de Cloud Shell. Eche un vistazo a un paso en particular en el tutorial como se muestra a continuación:




El fragmento de código para esto se muestra a continuación:


## Source Code
Let us go through the JavaScript file to understand the source code.
Click here: `walkthrough editor-open-file “Google-Cloud-Shell-Tutorial-Creation/index.js” “Open index.js”`

Preste atención al comando tutorial, el formato es el que se muestra a continuación:


`walkthrough editor-open-file path/to/somefile "Label Text"`

Todo lo que necesita hacer es proporcionar la ruta completa al archivo que desea abrir en el editor, en nuestro caso el archivo index.js. Y proporcione una etiqueta de texto que se representará en el Paso de tutorial. Si el usuario hace clic en él, el editor se abrirá con el archivo como se muestra a continuación en el panel izquierdo.




Esto facilita al usuario concentrarse en el tutorial y no distraerse con la navegación a alguna carpeta, etc. La experiencia vuelve a entrar en juego.


También hay otros elementos personalizados compatibles como Spotlight, que indican un icono de Cloud Shell, etc. Consulte la documentación. Estos son elementos valiosos para apoyar una gran experiencia para el lector.




Publicando y lanzando el tutorial


Hay varias formas de iniciar el tutorial, pero prefiero lo siguiente:

1.- Primero publico el código fuente completo para el tutorial como repositorio en Github. Por ej. aquí está el repositorio de Github para el tutorial que creé: 
2.- En este repositorio, fijate que coloqué el archivo tutorial.md que contiene nuestro código de markdown de tutorial como se explicó anteriormente en la carpeta raíz.
 
3.- En el archivo README.md, debe agregar un botón Iniciar en Google Cloud Shell como se muestra a continuación:

4. Puede agregar el botón de la siguiente manera:


[![Open in Cloud Shell](http://gstatic.com/cloudssh/images/open-btn.png)](https://console.cloud.google.com/cloudshell/open?git_repo=YOUR_REPO_URL&tutorial=YOUR TUTORIAL FILE NAME)

Solo necesita proporcionar dos variables:


  •     git_repo: la URL completa del repositorio de Git
  •     tutorial: el nombre del archivo tutorial. Por ej. tutorial.md

El parámetro tutorial es una sugerencia para el Cloud Shell que una vez que ha configurado el repositorio, necesita iniciar el tutorial presente en tutorial.md. Esto abrirá el primer paso del tutorial en el panel derecho.


Algunas observaciones


    Si ha estado usando Google Cloud Platform, se habría encontrado con Google Codelabs. No creo que esto sea un sustituto, pero definitivamente puede facilitar el proceso de configuración de un entorno de Cloud Shell con los archivos configurados para usted.


    Si nunca ha visto Google Codelabs, hágalo. Hay toneladas de tutoriales para que se familiarice con varios servicios de GCP. ¡Hazlo ahora!

2. La estructura de carpetas que ves en mi repositorio github no es la que se debe seguir estrictamente. Puede organizar sus carpetas como mejor le parezca. Solo asegúrese de proporcionar la ruta correcta cuando use elementos personalizados para abrir el archivo en el editor y también para hacer referencia a su archivo de revisión tutorial. Prueba con ensayo y error.


3. Si ve la documentación oficial, se le solicita que use `` `...` `` para el bloque de código. Pero descubrí que, a menos que use `` `bash ...` ``, no se procesó como se esperaba.


4. Hay algunos comandos de recorrido ocultos, como el trofeo de conclusión del recorrido, que no están documentados. Te presenta un buen trofeo cuando completas las cosas.


5. La experiencia y las capacidades de los tutoriales se centran en Cloud Shell. Entonces tu imaginación está limitada por lo que puedes hacer con comandos shell del Cloud. Por ej. Incluso quería llevar al usuario a Cloud Console y automatizar algunas pantallas allí, pero creo que estoy cruzando la línea aquí.


6. Notarás que hay botones para enviar comentarios para el tutorial. Esto incluye una calificación para su tutorial y una descripción del usuario en caso de que haya problemas. No estoy seguro de a dónde se envían los comentarios.


Eso lleva a este tutorial sobre la creación de tutoriales a un final. ¡Disfruta creando tus tutoriales para Cloud Shell!



Referencias



jueves, 13 de septiembre de 2018

Felipe Martina nos habla de su experiencia de AWS con Google Cloud

Para aquellos que no pudieror asistir a nuestra meetup online en el dia de hoy les dejo un link para que puedan ver la grabacion en youtube. Felipe nos ha contando un poco de su experiencia y las diferencias entre GCP y AWS, y Mario Ezquerro nos dio una buena introduccion a GCP AppEngine con TravisCI.

martes, 11 de septiembre de 2018

Crear tutoriales de Google Cloud Shell 1/2


Hoy os paso de uno de mis Bloggeros favoritos Romin Irani un traducción de su presentación de como crear tutoriales para Google Cloud Shell

A Romin Irani  le encanta escribir tutoriales, termina escribiéndolas como publicaciones de blog (bastante detalladas) y hace todo lo posible para no perder un paso y dar capturas de pantalla de qué esperar encontrar en el progreso.

Ademas dado el ritmo con el que se lanzan nuevas versiones de software,  se esta en desventaja  cuando se trata de mantener el material actualizado. ¿Hay alguna mejor experiencia que les pueda dar a mis lectores que sea consciente del hecho de que simplemente les gustaría ponerse en marcha rápidamente, tener el código listo, simplemente ver que todo funciona y que tiene casi suficientes instrucciones y teoría? Un enfoque puede ser la creación de videos, pero también me resulta difícil actualizarlos.


Una función recientemente lanzada en Google Cloud Platform le permite crear un tutorial que se ejecuta dentro de Google Cloud Shell. Esto definitivamente abre múltiples posibilidades y todo lo que se necesita hacer para mantener este tutorial actualizado es, probablemente, cambios de texto mínimos y actualizaciones de código. Creo que tiene un gran potencial y estoy entusiasmado con eso.


Esta publicación de blog tratará acerca de cómo crear tutoriales que brinden una experiencia fluida al usuario en términos de empaquetar todo el código necesario para ejecutar su tutorial, proporcionarlo en Cloud Shell y proporcionar instrucciones paso a paso que ayuden al lector a seguir a lo largo, en verdadero estilo tutorial.


Tutorial de Cloud Shell en acción


Veamos primero lo que estamos tratando de crear. Eso hará las cosas mucho más fáciles de entender cuando se trata de escribir un tutorial similar al que leera en breve.


    Los únicos requisitos previos para ejecutar este tutorial es tener una cuenta de GCP.


Por favor visite la siguiente URL:


Cuando visite la página anterior, se le dirigirá al archivo README.md, cuyo fragmento se muestra a continuación:



Intenté demostrar cómo escribir un tutorial que se ejecuta en Google Cloud Shell y te enseño sobre Google Cloud Natural Language API a través de una experiencia que se parece a un codelab, pero va un paso más allá configurando todo el código con acceso directo para usar en Cloud Shell. Podras ver que se  ejecutar rápidamente.


    No necesita ejecutar todo el tutorial, bastará con hacer algunos pasos para darle una buena idea de lo que está pasando.


Haga clic en el botón azul titulado "Abrir en Google Cloud Shell". Lo que sucede a continuación es pura magia.


Utiliza su cuenta de Google Cloud Platform e inicia Google Cloud Shell y le solicita permiso para clonar el Git Repo como se muestra a continuación. Haga clic en CONTINUAR.



A continuación, avanza a la configuración de un área de trabajo para usted como se muestra a continuación.



Si todo va bien, tendrá una sesión de Cloud Shell que se verá así:


  1. Espacio de trabajo con las carpetas / archivos clonados del proyecto.
  2. El terminal de Cloud Shell con el directorio actual establecido en la carpeta en la que se clonó el proyecto.
  3. El tutorial paso a paso se lanza para usted a la derecha. Contiene las instrucciones que das y puedes continuar con el tutorial haciendo clic en el botón azul Continuar.


Pruébalo y sigue los siguientes pasos y si realmente los pruebas en la sesión de la terminal, incluso aprenderás sobre la API de Cloud Natural Language :-)

martes, 28 de agosto de 2018

GPU Tesla V100 ahora están disponibles en Google Cloud


Hoy nos han anunciado que ya esta disponible en Google Cloud las (GPU) NVIDIA V100 con NVLink a disposición. Estas GPU ofrecen una potencia importante para cargas de trabajo computacionales complejas.

Aparte de las nuevas V100, junto con estas ya se tenian disponibles GPU K80, P100 y P4, son excelentes para acelerar muchas cargas de cómputo y HPC alimentadas por CUDA. La GPU V100 destaca especialmente por las cargas de trabajo de AI.

Cada GPU V100 tiene 640 núcleos de tensor y ofrece hasta 125 TFLOPS de rendimiento mixto ML de precisión. Esto significa que puede obtener hasta un rendimiento de petaFLOP de ML en una sola máquina virtual (VM), lo que lo convierte en una herramienta de procesamiento muy potente para el entrenamiento ML y las cargas de trabajo de inferencia. Además, para las cargas de trabajo más exigentes, se dispone de la  red NVLink de alta velocidad entre GPU de hasta 300 GB / sy SSD local opcional para E / S de disco rápido.


Un cliente de V100 que utiliza Compute y Kubernetes Engine que trabaja en el desarrollo y la promoción de inteligencia artificial artificial segura. Usan las GPU V100 y P100, junto con las máquinas virtuales (VM) exclusivas para CPU, para ejecutar grandes trabajos de aprendizaje de refuerzo para entrenar a AI para jugar de forma cooperativa en juegos multijugador y prepararse para la competencia The International Dota 2.


En primer lugar, aumentamos la flexibilidad agregando soporte para conectar dos o cuatro V100 a una VM, lo que significa que ahora hay soporte para conectar uno, dos, cuatro u ocho V100 por VM. Esto es importante ya que le permite hacer coincidir su carga de trabajo con la cantidad óptima de potencia de la GPU. Esto más la característica personalizada de VM le permite crear una forma de máquina virtual con la CPU, la memoria, el almacenamiento y el rendimiento de la GPU V100 que satisfaga sus necesidades.


En segundo lugar, facilitamos el inicio de las GPU en Compute Engine para ML y otras cargas de trabajo informáticas al ofrecer nuevas imágenes del sistema operativo preconfiguradas y optimizadas para la carga de trabajo y el rendimiento. Simplemente cree una máquina virtual con una GPU, elija una de ellas con bibliotecas preinstaladas y comience. Estas imágenes funcionan para todas las plataformas GPU-K80, P100, P4 y V100- y vienen en tres Configuraciónes: TensorFlow, PyTorch y Base.

Los tres incluyen las últimas versiones de las herramientas de NVIDIA de las que dependen: CUDA 9.2, CuDNN 7.2 y NCCL 2.2, y son una buena opción para las cargas de trabajo de ML. La imagen base también se puede usar para otras cargas de trabajo de cómputo, como HPC, que vienen con controladores GPU preconfigurados. El uso de estas imágenes le brinda las optimizaciones de rendimiento para el uso de GPU en GCP, y en particular ayuda realmente al usar múltiples GPU V100 con NVLink para cargas de trabajo de aprendizaje profundo. Para obtener más información y para comenzar, consulte nuestra documentación de imágenes.

En tercer lugar, se ha bajado los  precios de GPU prioritarios para todas las plataformas de GPU, incluidos los V100, hasta un 70% de descuento en los precios según demanda. Esto proporciona a cualquier organización una oferta informática de muy bajo costo y elimina tener que lidiar con los precios fluctuantes de un sistema de subastas. Esto es crítico si usted está haciendo ML o HPC trabajan con un presupuesto limitado, pero son lo suficientemente flexibles como para manejar las limitaciones que vienen con máquinas virtuales "preemtibles", como una vida útil máxima de 24 horas.

¿Querer aprender más? Visite la página de productos GPU para obtener información general y precios. O formese con la documentación de GPU para conocer la disponibilidad de ubicación y cómo comenzar.

viernes, 24 de agosto de 2018

Migrar a GCP con CloudEndure (IV) – Test y Cut-Over

Una de las opciones más interesantes que tiene CloudEndure es que puedes probar las replicas que estás haciendo para verificar que son funcionales. Esto es fundamental si estás utilizando Google Cloud como solución de Disaster Recovery para tu plataforma on-premises.
Si entráis en la consola de GCP, veréis que hay máquinas y snapshots que no habéis creado vosotros. Son los que crea CloudEndure y después se utilizan para lanzar los Test y CutOver.

Para lanzar una prueba simplemente elegimos la máquina que queremos probar y le decimos “Test Mode”. También lo podemos hacer desde los detalles particulares de la máquina, donde se definía el Blueprint
Esto va a empezar a realizar diferentes tareas en nuestra plataforma GCP. Estas tareas las podremos ir viendo desde la pestaña de Job Progress . Estas tareas incluyen la creación de la máquina, discos, reglas de firewall, etc..
Una vez realizadas todas las tareas, ya podremos acceder a la réplica como si fuera cualquier otra máquina y probar que todo está correcto. Los datos de conexión (direcciones IP públicas, etc…) están en la consola de Google. Hay que recordar que la réplica se ha lanzado con la configuración que pusimos en el Blueprint, por lo que si hemos especificado una dirección IP para esa máquina, podríamos acceder utilizando dicha dirección IP (siempre que tengamos otra máquina accesible dentro de esa red, claro 🙂

Como veis ha creado una máquina llamada ubuntu-replica, que es tal cual la habíamos llamado en el Blueprint y está dentro de la red 192.168.1.0/24 que es la que estaba definida dentro de nuestro VPC.
Aqui la conexión desde la máquina instance-1 a la replica que hemos lanzado que se llamaba  ubuntu-replica.

En la consola de CloudEndure vereis que la maquina ahora ya aparece como testada (último icono de STATUS):

Una vez terminada la prueba, borramos la VM y ya estaría todo.
En caso de que lancemos un nuevo Test de una máquina que ya tiene su replica funcionando en GCP, CloudEndure borrará la replica existente en GCP y lanzará la nueva utilizando el último snapshot. De esta forma, se mantiene la consistencia.
Cut-Over
Cut-Over sería la operación correspondiente a paso a producción de la máquina. En nuestro caso, supondría que ya estamos listos para utilizar la máquina en GCP porque hemos testado la replica y es satisfactoria y ya podríamos apagar las máquinas on-premises.
A efectos técnicos, no tiene ninguna diferencia frente a una operación Test, la única diferencia es a nivel de CloudEndure que Test lo marco como “Probado” y CutOver lo marca como “CutOver” para facilidad nuestra de saber que hemos probado y que hemos pasado ya a productivo, pero no supone ninguna diferencia técnica.

Conclusión

Con todos estos posts, hemos enseñado como pasar máquinas Linux o Windows a la plataforma cloud de Google de una manera sencilla, y gratuita. Y las posibilidades que tiene son muchísimas.
En el siguiente (y último post de esta serie) haremos un resumen de las funcionalidades y las impresiones que nos ha causado CloudEndure.