Mostrando entradas con la etiqueta truco. Mostrar todas las entradas
Mostrando entradas con la etiqueta truco. Mostrar todas las entradas

jueves, 1 de agosto de 2019

Cómo programar un script de Python en GCP


Tal vez estés ejecutando una consulta en BigQuery y descargando los resultados en BigTable cada mañana para realizar un análisis. O quizás necesite actualizar los datos en una tabla dinámica en Google Sheets para crear un histograma  para mostrar sus datos de facturación. En cualquier caso, a nadie le gusta hacer lo mismo todos los días si la tecnología puede hacerlo por ti. ¡Contempla la magia de Cloud Scheduler, Cloud Functions y PubSub!

Cloud Scheduler es un producto administrado de Google Cloud Platform (GCP) que te permite especificar una frecuencia para programar un trabajo recurrente. En pocas palabras, es un planificador de tareas gestionado ligero. Esta tarea puede ser un trabajo por lotes ad hoc, un trabajo de procesamiento de big data, herramientas de automatización de infraestructura, lo que sea. Lo bueno es que Cloud Scheduler se encarga de todo el trabajo ademas  se reintenta en caso de fallo e incluso le permite ejecutar algo a las 4 AM, para que no tenga que despertarse en medio de la noche para correr una carga de trabajo en otro momento fuera de hora punta.


Al configurar el trabajo, puedes determinar qué exactamente "disparará" en un momento concreto Puede tratarse de un publicación en un  PubSub,  o un end-point de  HTTP o una aplicación App Engine. En este ejemplo, publicaremos un mensaje a un tema de PubSub.

Nuestro tema de PubSub existe únicamente para conectar los dos extremos de nuestra canalización: es un mecanismo intermediario para conectar el trabajo de Cloud Scheduler y la función en cloud que contiene la secuencia de comandos de Python real que ejecutaremos. Esencialmente, el tema de PubSub actúa como una línea telefónica, proporcionando la conexión que permite que el trabajo del Programador del cloud  hable y la Función de la Nube para escuche. Esto se debe a que el trabajo de Cloud Scheduler publica un mensaje al tema. La función de nube se suscribe a este tema. Esto significa que se alerta cuando se publica un nuevo mensaje. Cuando recibe una alerta, ejecuta el script de Python.

The Code

SQL

Para este ejemplo,  mostraré un script de Python simple que quiero ejecutar diariamente a las 8 AM  y las 8 PM . El script es básico: ejecuta una consulta SQL en BigQuery para encontrar los repositorios populares de Github. Buscaremos específicamente qué propietarios crearon repositorios con la mayor cantidad de contenedores y en qué año se crearon. Usaremos datos del conjunto de datos público bigquery-public-data: sample, que contiene datos sobre los repositorios creados entre 2007 y 2012.

Nuestra consulta SQL tiene este aspecto:

SELECT
  SUM(repository.forks) AS sum_forks,
  repository.owner,
  EXTRACT(YEAR FROM PARSE_TIMESTAMP('%Y/%m/%d %H:%M:%S %z', repository.created_at)) AS year_created
FROM
  `bigquery-public-data.samples.github_nested`
WHERE
  repository.created_at IS NOT NULL
GROUP BY
  2,
  3
ORDER BY
  3 DESC

Python

Pronto pegaremos esta consulta en nuestro archivo github_query.sql. Esto se llamará en nuestro archivo main.py, que llama a una función principal que ejecuta la consulta en Python mediante el uso de Python Client Library para BigQuery.

Paso 1: asegúrese de tener Python 3 e instale e inicialice el SDK de google cloud. Lo siguiente les una guia a través de cómo crear el entorno GCP. Si desea probarlo localmente, asegúrese de haber seguido primero las instrucciones para configurar Python 3 en GCP.

Paso 2: crea un archivo llamado requirements.txt y copia y pega lo siguiente:

  google-cloud-bigquery
Paso 3: Crea un archivo llamado github_query.sql y pega en la consulta SQL desde arriba.

Paso 4: Cree un archivo llamado config.py y edítelo con sus valores para las siguientes variables.

Puede usar un conjunto de datos existente para esto o elegir un ID de un nuevo conjunto de datos que creará, solo recuerde el ID ya que lo necesitará para otorgar permisos más adelante.

  config_vars = {
    'project_id': [ENTER YOUR PROJECT ID HERE],
    'output_dataset_id': '[ENTER OUTPUT DATASET HERE]',
    'output_table_name': '[ENTER OUTPUT TABLE NAME HERE]',
    'sql_file_path': 'github_query.sql'
}
Paso 4: Cree un archivo llamado main.py que haga referencia a los dos archivos anteriores.

"""Function called by PubSub trigger to execute cron job tasks."""
import datetime
import logging
from string import Template
import config
from google.cloud import bigquery

def file_to_string(sql_path):
    """Converts a SQL file holding a SQL query to a string.
    Args:
        sql_path: String containing a file path
    Returns:
        String representation of a file's contents
    """
    with open(sql_path, 'r') as sql_file:
        return sql_file.read()


def execute_query(bq_client):
    """Executes transformation query to a new destination table.
    Args:
        bq_client: Object representing a reference to a BigQuery Client
    """
    dataset_ref = bq_client.get_dataset(bigquery.DatasetReference(
        project=config.config_vars['project_id'],
        dataset_id=config.config_vars['output_dataset_id']))
    table_ref = dataset_ref.table(config.config_vars['output_table_name'])
    job_config = bigquery.QueryJobConfig()
    job_config.destination = table_ref
    job_config.write_disposition = bigquery.WriteDisposition().WRITE_TRUNCATE
    sql = file_to_string(config.config_vars['sql_file_path'])
    logging.info('Attempting query on all dates...')
    # Execute Query
    query_job = bq_client.query(
        sql,
        job_config=job_config)

    query_job.result()  # Waits for the query to finish
    logging.info('Query complete. The table is updated.')

def main(data, context):
    """Triggered from a message on a Cloud Pub/Sub topic.
    Args:
        data (dict): Event payload.
        context (google.cloud.functions.Context): Metadata for the event.
    """
    bq_client = bigquery.Client()

    try:
        current_time = datetime.datetime.utcnow()
        log_message = Template('Cloud Function was triggered on $time')
        logging.info(log_message.safe_substitute(time=current_time))

        try:
            execute_query(bq_client)

        except Exception as error:
            log_message = Template('Query failed due to '
                                   '$message.')
            logging.error(log_message.safe_substitute(message=error))

    except Exception as error:
        log_message = Template('$error').substitute(error=error)
        logging.error(log_message)

if __name__ == '__main__':
    main('data', 'context')
Para implementar la función en GCP, puede ejecutar los siguientes comandos de gcloud. Esto especifica el uso de un tiempo de ejecución de Python 3.7,
La creación de un tema de PubSub con un nombre de su elección y la especificación de que esta función se activa cada vez que se publica un nuevo mensaje sobre este tema. También esta establecido el tiempo de espera al máximo que GCP ofrece de 540 segundos o nueve minutos.

gcloud functions deploy [FUNCTION_NAME] --entry-point main --runtime python37 --trigger-resource [TOPIC_NAME] --trigger-event google.pubsub.topic.publish --timeout 540s
Asegúrese de que primero cd en el directorio donde se encuentran los archivos antes de la implementación, de lo contrario no funcionará lo siguiente.

Especifica la frecuencia con la que se ejecutará la función de la nube en el tiempo cron de UNIX al configurar el programador del Cloud  con el indicador de programación. Esto significa que publicará un mensaje al tema de PubSub cada 12 horas en la zona horaria UTC, como se ve a continuación:

gcloud scheduler jobs create pubsub [JOB_NAME] --schedule [SCHEDULE] --topic [TOPIC_NAME] --message-body [MESSAGE_BODY]
donde [JOB_NAME] es un nombre único para un trabajo, [SCHEDULE] es la frecuencia para el trabajo en UNIX cron, como "0 * / 12 * * *" para ejecutar cada 12 horas, [TOPIC_NAME] es el nombre del tema creado en el paso anterior cuando implementó la función de nube, y [MESSAGE_BODY] es cualquier cadena. Un ejemplo de comando sería:


gcloud scheduler jobs create pubsub daily_job --schedule "0 */12 * * *" --topic my-pubsub-topic --message-body "This is a job that I run twice per day!"

Nuestro código de Python no usa el mensaje real. ¡Este es un trabajo que ejecuto dos veces por día! "" Publicado en el tema porque solo estamos ejecutando una consulta en BigQuery, pero vale la pena señalar que puede recuperar este mensaje y actuar. tal, como para fines de registro o de otro tipo.

Conceder permisos
Finalmente, abra la interfaz de usuario de BigQuery y haga clic en "Crear conjunto de datos" en el proyecto al que hizo referencia anteriormente.

Al crear la Función de la nube, creó una cuenta de servicio con el correo electrónico en el formato [PROJECT_ID] @ appspot.gserviceaccount.com. Copia este correo electrónico para el siguiente paso.

Pase el cursor sobre el ícono Más para este nuevo conjunto de datos.

Haga clic en "Compartir conjunto de datos".

En la ventana emergente, ingrese el correo electrónico de la cuenta de servicio. Dale permiso "Can Edit".

Ejecutar el trabajo:
Puede probar el flujo de trabajo anterior ejecutando el proyecto ahora, en lugar de esperar la hora programada de UNIX. Para hacer esto:


  1. Abre la página de Cloud Scheduler en la consola.
  2. Haz clic en el botón "Ejecutar ahora".
  3. Abre BigQuery en la consola.
  4. Debajo de su conjunto de datos de salida, busque su [output_table_name], esto contendrá los datos.


Para obtener más información, lea nuestra documentación sobre la configuración de Cloud Scheduler con PubSub trigger y pruébelo utilizando uno de nuestros conjuntos de datos públicos de BigQuery.

martes, 8 de enero de 2019

Como crear un Job de kubernetes en GCP


¿Que es un Job?


Un Job en kubenetes es un proceso que tiene un inicio y un fin, una vez creado un Job este se elimina automáticamente del Node luego de finalizar su trabajo.

Existen varias políticas de de restart pod en kubernetes pero para este caso es mejor usar la política Never por si este generara alguno tipo de error no se reinicie.

Los Job en kubenertes básicamente crean un Pod con una imagen asociada con el algoritmo que queremos ejecutar y este muere luego de finalizar dicho algoritmo.






La imagen muestra un archivo con extensión .yaml que tiene las especificaciones que le vamos a dar al kubenertes para que nos cree nuestro Job.

image: es la imagen alojada en Docker Registry que contine un fichero donde esta alojada la lógica del Job.

command: es lo que va a hacer el Job.

restarPolicy: es la política de restart del pod que definimos en este caso nunca se va a reiniciar si tiene algún error, de tener error muere el pod.

El comando a ejecutar para crear un Pod de tipo Job es kubectl create -f file_name.yaml.

martes, 29 de mayo de 2018

Creando Diagramas de Google Cloud Platform



En esta entrada de Google Cloud Español os hablare que software de diagrama  podríamos usar para representar los objetos de plataforma Google Cloud y proporcionar soluciones donde mostrar los diagramas de arquitectura GCP. Ademas Puede crear fácilmente cualquier diagrama de la plataforma Google Cloud utilizando sus iconos GCP prefabricados, Pero para empezar.....

¿Qué son los iconos de Google Cloud Platform?


Google te proporciona un  conjunto de iconos oficiales de Google Cloud Platform para crear diagramas de su arquitectura.


También hay 50 diagramas de muestra que puedes abrir en las Presentaciones de Google, en PowerPoint y en Lucidchart. Estos iconos y diagramas están pensados para hacer referencia a las herramientas y a la tecnología de Google de forma precisa en arquitecturas, entradas de blog, informes, hojas de datos, carteles y otros materiales técnicos.


Software para Diagramas de Google Cloud Platform


Hay distintos incluso pero yo uso u recomiendo el software draw.io que ofrece funciones y funciones de proyectos de Google Cloud Platform con varios íconos, símbolos y la conveniente interfaz de usuario de arrastrar y soltar. Puede crear rápidamente cualquier diagrama de GCP arrastrando y soltando iconos de GCP, organizándolos y conectándolos, y anotándolos con texto. Una vez hecho, también puede guardar su trabajo en la nube o exportarlo en diferentes formatos, incluidos documentos PDF y de Office.

draw.io


Ademas Google nos proporciona un  conjunto de iconos oficiales de Google  para esta herramienta y funciona en un entorno web de cualquier plataforma, una aplicación web que nos permite crear diagramas de todo tipo desde nuestro navegador, de manera cómoda y sin tener que adquirir licencias de Microsoft Visio o similares.Draw.io tiene además la ventaja de incluir ya imágenes de Amazon, Microsoft Azure, Veeam, y muchos otros, y además viene con ejemplos.



martes, 15 de mayo de 2018

Guardar un archivo en Cloud Storage usando Python

La idea de este articulo es que se pueda subir un archivo de cualquier tipo (pdf,image,etc) a tu Bucket en el Storage de Goolge usando algunas lineas de Python.

#1) Lo Primero que debemos de hacer es la instalación de la libreria.


$ pip install google-cloud-storage



#2) Las siguientes lineas de código muestran como de fácil se pueden subir archivos al Cloud Storage justo al lado comentare que significa cada una para dejar todo claro.


#Librerias necesarias
$ from google.cloud.storage import Blob
$ from google.cloud import storag

#Se instancia la clase de Cloud Storage para poder comunicarnos directamente con la nube.
$ client = storage.Client(project='PROJECT-ID')
#Seleccionamos el bucket necesario para realizar las operaciones que queramos como subir archivos.
$ bucket = client.get_bucket('NAME-BUCKET')

#Se crea un Objeto de tipo Blob con un nombre que deseamos que vaya a tener dentro del bucket.
$ blob = Blob('NAME.png', bucket)

#Ahora le decimos al blog que suba el archivo en dicha dirección a nuestro bucket pasando dos parametros la PATH del file y el contentex type.
$ blob.upload_from_filename('/PATH/TO/FILE.png','image/png')
#Hacemos que el archivo sea publico si así lo deseamos
$ blob.make_public()

#Se imprime la url del bucket para poder acceder al archivo a través de ella esta luego puede ser compartida o guardada en una BD.
$ print blob.public_url


Así de simple con una cuantas lineas de Python podemos incrustar en nuestra aplicación el uso del Cloud Storage de Google.

Les dejo el enlace de la librería para que puedan explorar las diversas opciones que se pueden hacer en el Storage y puedan adaptarlas a sus necesidades.

Cloud Storage

lunes, 12 de marzo de 2018

El CLI ahora en interactivo en google cloud

Hoy en google cloud en español os presentamos una nueva capacidad del entorno CLI de Google cloud.



Si creas aplicaciones en Google Cloud Platform (GCP), a línea de comando de GCP tiene que ser tu amiga. Pero a medida que crecemos nuestros servicios de BPC, la cantidad de comandos  crece a pasos agigantados. Pero hay nueva interfaz de línea de comandos (CLI) que le permite descubrir y usar todos estos comandos de manera más eficiente: gcloud interactive.

Google Cloud SDK ofrece una variedad de herramientas de línea de comandos para interactuar con google cloud platform:

  • gcloud: CLI principal de GCP
  • gsutil - CLI para interactuar con Google Cloud Storage
  • bq - CLI para interactuar con Google BigQuery
  • kubectl - CLI de Kubernetes Engine


Actualmente en alfa pública, el nuevo entorno CLI interactivo proporciona indicaciones automáticas y ayuda en línea para los comandos gcloud, gsutil, bq y kubectl. Ya nos podemos ahorrar, ya  medida que busca nombres de comando, indicadores necesarios o tipos de argumentos en las páginas de ayuda. ¡Ahora toda esta información se incluye como parte del entorno interactivo mientras escribe!


El entorno interactivo también admite funciones bash estándar como:
  • Entremezclando gcloud y comandos bash estándar
  • Ejecutar comandos como cd y pwd, y establecer / usar variables de shell en ejecuciones de comandos
  • Ejecutando y controlando procesos en segundo plano
  • TAB-completar variables de shell, y mucho más!


Por ejemplo, puede asignar el resultado del comando a una variable y luego llamar a esta variable como una entrada a un comando diferente:


$ active_vms=$(gcloud compute instances list --format="value(NAME)" --filter="STATUS=RUNNING")
$ echo $active_vms



También puede crear y ejecutar scripts bash mientras se encuentra en el entorno interactivo.


Por ejemplo, la siguiente secuencia de comandos itera todas las instancias de cálculo y reinicia las que han sido TERMINADAS.


#!/bin/bash
terminated_vms=$(gcloud compute instances list --format="value(NAME)" --filter="STATUS=terminated")
for name in $terminated_vms
do
  echo "Instance $name will restart."
  zone=$(gcloud compute instances list --format="value(ZONE)" --filter="NAME=$name")
  gcloud compute instances start $name --zone $zone 
done







Comenzando con gcloud interactivo

Una vez que haya instalado Google Cloud SDK, siga adelante y pruebe gcloud interactive: (si aún no lo ha instalado, puede ver las instrucciones en este enlace)

1. Asegúrese de que los componentes de su SDK estén actualizados.

$ gcloud components update


2. Instala el componente alpha de gcloud.

$ gcloud components install alpha



3. Comience gcloud interactivo

$ gcloud alpha interactive



[Opcional] Habilite el modo interactivo para gsutil, bq y kubectl (está habilitado para gcloud de manera predeterminada.) Tenga en cuenta que esto puede tardar unos minutos en completarse, pero solo necesita ejecutar este comando una vez.

$ gcloud alpha interactive --update-cli-trees


Trucos:


  • Cuando desee obtener más información sobre el comando actual que escribió, presione F8 para abrir la página de referencia en el navegador.
  • Puede establecer el contexto de solicitud en cualquier grupo de comandos. Esto es útil si trabaja principalmente con ciertos grupos de comandos y le ahorra tener que escribir el comando completo cada vez. Puede hacer esto escribiendo el grupo de comando y presionando F7.
  • Active y desactive el área de ayuda interactiva con la tecla F2.

  • Use la tecla F3 para alternar el modo de edición de línea de comando entre emacs y vi.

Haga clic aquí para obtener más información acerca de gcloud interactive, y comente qué piensa utilizando el comando gcloud feedback.

martes, 23 de enero de 2018

How to Use Google Cloud Platform, [Otra joya de documentación dentro de google cloud]

Hoy en google cloud español...

Os mostramos otra joya de esas que se encuentran dentro de la web de documentación de google cloud.

Tal y como nos tienen acostumbrados hay mucha información tanta que abruma. Uno de los recursos de la web de google Cloud es usar el enlace que os paso que tiene  cantidad de información sobre ejemplos prácticos del uso de los distintos servicios de google cloud.

Mira que dentro de la web debajo del recuadro azul "Note", ademas tiene un buscados. Os pasamos un ejemplo par localizar ejemplos de despliegues de CI/CD dentro de Google cloud

Enjoy



https://cloud.google.com/docs/tutorials#development_and_test


Imagen de captura de una búsqueda.

sábado, 20 de enero de 2018

Cluster de Servidores para juegos con kubernetes.

Hoy en google cloud español.
Por Joseph Holley



Ejecución de servidores de juegos dedicados en Kubernetes Engine:

Las empaquetar aplicaciones de servidor dcomo imágenes de contenedor están ganando terreno rápidamente en organizaciones tecnológicas, compañías de juegos entre ellas. Quieren utilizar contenedores para mejorar la utilización de VM, así como aprovechar el paradigma de tiempo de ejecución aislado. A pesar de su interés, muchas compañías de juegos no saben por dónde empezar.

Usar el marco de orquestación Kubernetes para desplegar flotas de escala de producción de servidores de juegos dedicados en contenedores es una excelente opción. Recomendamos Google Kubernetes Engine como la forma más fácil de iniciar un clúster de Kubernetes para servidores de juegos en Google Cloud Platform (GCP) sin pasos de configuración manual. Kubernetes ayudará a simplificar la administración de su configuración y seleccionará una máquina virtual con los recursos adecuados para generar automáticamente una coincidencia para sus jugadores.

Recientemente, han creado un tutorial que muestra cómo integrar servidores de juegos dedicados con Kubernetes Engine, y cómo escalar automáticamente el número de VMs según la demanda de los jugadores. También ofrece algunas estrategias de almacenamiento clave, que incluyen cómo administrar los activos de su servidor de juegos sin tener que distribuirlos manualmente con cada imagen de contenedor. Compruébalo y cuéntanos otras herramientas de Google Cloud que te gustaría aprender a usar en tus operaciones de juego. Puedes contactar  con el creador en Twitter en @gcpjoe.

miércoles, 17 de enero de 2018

Aumenta tu seguridad usando contenedores con kubernetes

Seguridad  google cloud español y de contenedores con Kubernetes Engine 1.8


De entrada partimos de la versión 1.7, la UI de Kubernetes ya no tiene acceso de administrador habilitado por defecto. Si no está utilizando Kubernetes Engine, le recomiendo que lea este artículo sobre Control de acceso para el Dashboard. Si es así, recomendamos desactivarlo.

Con la velocidad del desarrollo en Kubernetes, a menudo hay nuevas características y configuraciones de seguridad que puede  que no conozca. Esta publicación le enseñara a través de la implementación de nuestra guía actual para reforzar su clúster de Kubernetes Engine. Si se siente con fuerzas, también analizaremos las nuevas funciones de seguridad que puede probar en clusters alfa (que no se recomiendan para uso de producción).

Las mejores prácticas de seguridad para su clúster de Kubernetes

Cuando se ejecuta un clúster de Kubernetes, existen varias prácticas recomendadas que recomendamos seguir:
  1. Utilice las cuentas de servicio de mínimo privilegio en sus nodos
  2. Deshabilitar la interfaz de usuario web de Kubernetes
  3. Inhabilite la autorización heredada (ahora está deshabilitada de forma predeterminada para los nuevos clústeres en Kubernetes 1.8). Pero antes de poder hacerlo, primero deberá establecer algunas variables de entorno:


#Your project ID
PROJECT_ID=
#Your Zone. E.g. us-west1-c
ZONE=
#New service account we will create. Can be any string that isn't an existing service account. E.g. min-priv-sa
SA_NAME=
#Name for your cluster we will create or modify. E.g. example-secure-cluster
CLUSTER_NAME=
#Name for a node-pool we will create. Can be any string that isn't an existing node-pool. E.g. example-node-pool
NODE_POOL=


1 Utilice las cuentas de servicio de mínimo privilegio en sus nodos

El principio de privilegio mínimo ayuda a reducir el "radio de explosión" de un posible compromiso, otorgando a cada componente solo los permisos mínimos requeridos para realizar su función. Si un componente se pone en peligro, el privilegio mínimo hace que sea mucho más difícil encadenar ataques juntos y escalar permisos.

Cada nodo de Kubernetes Engine tiene una cuenta de servicio asociada. Verá al usuario de la cuenta de servicio enumerado en la sección IAM de la consola de la nube como "cuenta de servicio predeterminada de Compute Engine". Esta cuenta tiene acceso amplio de forma predeterminada, por lo que es útil para una gran variedad de aplicaciones, pero tiene más permisos de los que necesita. para ejecutar su clúster de Kubernetes Engine.

Le recomendamos que cree y use una cuenta de servicio mínimamente privilegiada para ejecutar su Kubernetes Engine Cluster en lugar de la cuenta de servicio predeterminada de Compute Engine.

Kubernetes Engine requiere, como mínimo, que la cuenta de servicio tenga las funciones monitoring.viewer, monitoring.metricWriter y logging.logWriter.

Los siguientes comandos crearán una cuenta de servicio GCP para usted con los permisos mínimos necesarios para operar Kubernetes Engine:


gcloud iam service-accounts create "${SA_NAME}" \
  --display-name="${SA_NAME}"

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
  --member "serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role roles/logging.logWriter

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
  --member "serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role roles/monitoring.metricWriter

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
  --member "serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role roles/monitoring.viewer

#if your cluster already exists, you can now create a new node pool with this new service account.
gcloud container node-pools create "${NODE_POOL}" \
  --service-account="${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --cluster="${CLUSTER_NAME}"


Si necesita que su clúster de Kubernetes Engine tenga acceso a otros servicios de Google Cloud, le recomendamos que cree un rol adicional y lo suministre a las cargas de trabajo a través de los "secrets" de Kubernetes.

Nota: Actualmente se esta  diseñando un sistema para hacer que la obtención de credenciales GCP en su clúster de Kubernetes sea mucho más fácil y se reemplazar por completo este flujo de trabajo. Únase al Grupo de Trabajo de Identidad de Contenedores de Kubernetes para participar.

2. Deshabilitar la interfaz de usuario web de Kubernetes

Le recomendamos que desactive la interfaz de usuario web de Kubernetes cuando se ejecute en Kubernetes Engine. La interfaz de usuario web de Kubernetes (también conocida como Kubernetes Dashboard) está respaldada por una cuenta de servicio de Kubernetes altamente privilegiada. La consola de la nube proporciona muchas de las mismas funciones, por lo que no necesita estos permisos si está ejecutando Kubernetes Engine.

El siguiente comando desactiva la interfaz de usuario web de Kubernetes:

gcloud container clusters update "${CLUSTER_NAME}" \
    --update-addons=KubernetesDashboard=DISABLED


3a Deshabilitar la autorización heredada


A partir de Kubernetes 1.8, el control de acceso basado en atributos (ABAC) está desactivado por defecto en Kubernetes Engine. El control de acceso basado en roles (RBAC) se lanzó como beta en Kubernetes 1.6, y ABAC se mantuvo habilitado hasta 1.8 para dar a los usuarios tiempo para migrar. RBAC tiene importantes ventajas de seguridad y ahora es estable, por lo que es hora de desactivar ABAC. Si aún confía en ABAC, revise los requisitos previos para usar RBAC antes de continuar. Si actualizó su clúster desde una versión anterior y está utilizando ABAC, debe actualizar su configuración de controles de acceso:

gcloud container clusters update "${CLUSTER_NAME}" \
  --no-enable-legacy-authorization

Para crear un nuevo clúster con todas las recomendaciones anteriores, ejecute:

gcloud container clusters create "${CLUSTER_NAME}" \
  --service-account="${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --no-enable-legacy-authorization \
  --disable-addons=KubernetesDashboard


3b Crear una política de red de clúster

Además de las prácticas recomendadas antes mencionadas, le recomendamos que cree políticas de red para controlar la comunicación entre los Pods y Servicios de su clúster. La aplicación de la política de red de Kubernetes Engine, actualmente en versión beta, hace que sea mucho más difícil para los atacantes propagar dentro de su clúster. También puede usar la API de política de red de Kubernetes para crear reglas de firewall de nivel de Pod en Kubernetes Engine. Estas reglas de firewall determinan qué Pods y Servicios pueden accederse entre sí dentro de su clúster.

Para habilitar la aplicación de políticas de red al crear un nuevo clúster, especifique el indicador ---enable-network-policy usando gcloud beta:


gcloud beta container clusters create "${CLUSTER_NAME}" \
  --project="${PROJECT_ID}" \
  --zone="${ZONE}" \
  --enable-network-policy



Una vez que se haya habilitado la Política de red, deberá definir una política. Dado que esto es específico de su topología exacta, no podemos proporcionarle un tutorial detallado. La documentación de Kubernetes, sin embargo, tiene una excelente descripción y guía para una simple implementación de nginx.

Nota: Las funciones alfa y beta, como la API de políticas de red de Kubernetes Engine, representan mejoras de seguridad significativas en las API de GKE. Tenga en cuenta que las características alfa y beta no están cubiertas por ningún SLA o política de desactivación, y pueden estar sujetas a cambios bruscos en futuras versiones. No recomendamos que use estas funciones para clusters de producción.


Cierre

Muchas de las mismas lecciones que aprendimos de la seguridad de la información tradicional se aplican a Containers, Kubernetes y Kubernetes Engine; solo tenemos nuevas formas de aplicarlos. Adhiera al menor privilegio, minimice su superficie de ataque al deshabilitar la funcionalidad heredada o innecesaria, y la más tradicional de todas: redacte buenas políticas de firewall. Para obtener más información, visite la página web y la documentación de Kubernetes Engine. Si recién está comenzando con contenedores y Google Cloud Platform (GCP), asegúrese de registrarse para una prueba gratuita.

miércoles, 10 de enero de 2018

Tres trucos usando cloud load balancing

Hoy en google cloud español Tres consejos para el máximo rendimiento del un balanceador en google cloud.
Cuando necesitamos escalar nuestras aplicaciones en los servidores no tenemos que basar  en que se permitan que las solicitudes lleguen de una única ubicación a las las  máquinas virtuales. Ademas esta tecnología se puede usar junto con un escalador automático, y un equilibrador de carga también puede ayudar a sus aplicaciones a adaptarse a picos repentinos de peticiones en el tráfico.

Si está creando aplicaciones en Google Cloud Platform (GCP), Cloud Load Balancing le permite escalar sus aplicaciones, distribuir sus recursos en una o varias regiones y se integra con Cloud CDN. Aquí hay algunos consejos para ayudarlo a reducir los gastos generales de mantenimiento, mejorar el rendimiento y minimizar los costos, todo al mismo tiempo.

1. Aproveche el equilibrador de carga HTTP (S) donde pueda

Las principales funciones de un equilibrador de carga son su capacidad para manejar escalas automáticas y distribuir paquetes a las máquinas virtuales en ejecución. Cloud Load Balancing ofrece varias opciones para manejar esas necesidades exactas, pero el equilibrador de carga HTTP ofrece algo más: retira las solicitudes de Internet pública lo más rápido posible, lo que mejora el rendimiento al redirigir el tráfico a la red global de alta velocidad de Google. Visualizado, el resultado es:


El equilibrador de carga HTTP no solo aumenta el rendimiento porque los paquetes pasan menos tiempo en Internet, sino que también utiliza conexiones entre los clientes y los servidores front-end de Google, lo que ayuda a reducir aún más la carga de red de las solicitudes TCP de los usuarios.


2. Habilite Cloud CDN en solicitudes de caché

El almacenamiento en caché de las respuestas salientes de sus aplicaciones es fundamental para reducir los costos repetidos de obtención y entrega de recursos. Resulta que el equilibrador de carga de GCP hace que este proceso sea muy fácil gracias a la integración con Cloud CDN. Si habilita Cloud CDN para su equilibrador de carga, puede almacenar en caché automáticamente las solicitudes comunes para reducir la latencia, así como la cantidad de solicitudes que la instancia debe atender.

Siempre que la solicitud se guarde en caché, se servirá directamente en la red de Google.
Configurar esta función con Cloud Load Balancing es muy sencillo. Todo lo que necesita hacer es marcar el botón "Habilitar Cloud CDN" al crear la definición de back-end para sus HTTPs LB y GCP se ocupa del resto.


Este gráfico muestra la diferencia en el rendimiento de ir a buscar un activo con y sin Cloud CDN habilitado para el equilibrador de carga.


Puede ver que una vez que los recursos se almacena en caché, el tiempo de respuesta disminuye significativamente. No se necesitan instancias adicionales de almacenamiento en caché, ¡todo lo que tiene que hacer es marcar una casilla!



3. Combine Cloud CDN y Cloud Storage para activos estáticos

Las aplicaciones web tienden a tener una variedad de recursos estáticos y dinámicos. Los recursos que cambian muy raramente, por ejemplo, una imagen de banner o un logotipo de la empresa, se pueden separar, desde el punto de vista de los recursos, y se pueden servir de manera más eficiente mediante el almacenamiento en caché. Cloud Load Balancing hace que este proceso sea un poco más fácil.

Con Cloud Load Balancing, puede crear una ruta de enrutamiento de host a la que enrute su URL de activos estáticos designada para recuperar activos de un repositorio público de Cloud Storage que también se almacena en caché en Cloud CDN. Esto ayuda a reducir la complejidad y los gastos generales en el alojamiento y la administración de sus recursos estáticos. El almacenamiento en caché de estas solicitudes a través de Cloud CDN también produce un gráfico de aspecto muy similar al anterior:





Cada milisegundo cuenta

Al construir su aplicación nativa de la nube, siempre vale la pena considerar las tecnologías que pueden ayudar a optimizar sus diseños. Con estos tres consejos, los servicios de Cloud Load Balancing pueden ayudar a minimizar el mantenimiento a largo plazo, mejorar el rendimiento y reducir los costos. No está mal para unos pocos clics extra del mouse;)


Si desea obtener más información sobre cómo optimizar sus aplicaciones de Google Cloud, consulte el resto de las publicaciones y videos del blog de Google Cloud Performance. Porque, cuando se trata de rendimiento, cada milisegundo cuenta.

jueves, 4 de enero de 2018

Usando tareas App engine schedule cloud functions

En google cloud español publicado en 2018 Jan 04 por Guillaume Laforge

Aproveche las capacidades de cron de App Engine para "schedule" de Cloud Functions

Cloud Functions ofrece a los desarrolladores un entorno sin servidores, para permitirles crear y conectar servicios la cloud, una función a la vez. A día de hoy, todavía falta un aspecto: es la capacidad de programar invocaciones de función.

Digamos que desea obtener una función invocada en un intervalo regular: cada hora, se debe ejecutar alguna función de informe para informarle sobre el estado de sus pedidos. ¿Cómo puedes lograr esto? Nuestra solución en este artículo: aprovecharemos las capacidades cron de App Engine para enviar solicitudes a Cloud Functions.

Exponer una función de nube activada por HTTP

En primer lugar, creé un proyecto de Google Cloud con Cloud Functions habilitado, donde implementé una sencilla función de hello world:

exports.helloWorld = function helloWorld(req, res) {
  // Example input: {"message": "Hello!"}
  if (req.body.message === undefined) {
    // This is an error case, as "message" is required.
    console.log("No message received");
    res.status(400).send('No message defined!');
  } else {
    // Everything is okay.
    console.log(req.body.message);
    res.status(200).send('Success: ' + req.body.message);
  }
};
Esta función helloWorld es una función síncrona que responde a los triggers HTTP.

Para invocarlo (con fines de prueba), se pueden emitir llamadas CURL de la siguiente manera:

curl -X POST https://<REGION>-<PROJECT_ID>.cloudfunctions.net/helloWorld \
     -H "Content-Type: application/json" \
     --data '{"message": "Happy New Year!"}'
Y la función responderá con:

Success: Happy New Year!
Ahora veamos cómo aprovechar las colas de tareas y las capacidades cron de App Engine.

Configurar una pequeña aplicación de App Engine con una definición de cron

A los fines de esta demostración, estoy usando App Engine Standard con Java 8 runtime.

Nota: Mi aplicación utiliza el marco web de Gaelyk para App Engine, con el lenguaje de programación Apache Groovy. Pero la elección del marco web o del lenguaje no es crítica en este consejo, y puedes usar cualquier framework o lenguaje web compatible con App Engine. Sin embargo, en mi caso, mi proyecto se ejecuta en App Engine Standard y su reciente Java 8 runtime. Este aspecto es importante, ya que la forma de configurar las capacidades de cron varía según el tiempo de ejecución que elija. En el tiempo de ejecución de Java, las definiciones de cron utilizarán un formato XML (en lugar de YAML para otros tiempos de ejecución como Go).

Necesitamos hacer dos cosas para programar una invocación de función de nube:


  • Primero, creamos un archivo cron.xml en WEB-INF que define una URL local para nuestra aplicación App Engine, que reenviará las solicitudes entrantes a nuestra función. El archivo cron.xml especifica la programación (es decir, cada 10 minutos), así como una política de reintento opcional.
  • Luego, configuramos nuestra aplicación de App Engine para reenviar las solicitudes a la URL de cron.xml a la función.


Aquí está mi archivo cron.xml:

<cronentries>
  <cron>
    <url>/redirect-hello</url>
    <description>Redirect to the helloWorld function</description>
    <schedule>every 10 minutes</schedule>
  </cron>
</cronentries>
Mi función se invocará cada 10 minutos. Pero puede obtener más información sobre las posibles opciones de programación en la documentación.

Ahora, defino una nueva regla de enrutamiento para mi marco de trabajo web preferido para hacer el reenvío. Las definiciones de ruta se configuran en WEB-INF/routes.groovy en el marco de Gaelyk:

all "/call-hello", forward: "/callHello.groovy"
Definimos el path call-hello que llamará al controlador callHello.groovy, que se encuentra en WEB-INF/groovy. Echemos un vistazo a este controlador (también llamado groovlet) y veamos cómo llama a la función de nube:

out <<
    new URL('https://us-central1-fn-gae-cron.cloudfunctions.net/helloWorld')
        .post(payload: request.inputStream.bytes, 
              headers: ['Content-type': 'application/json'])
        .text
El controlador realiza una solicitud POST a nuestra función en la nube, pasando cualquier carga útil que se haya enviado a App Engine (aunque en nuestro caso, las llamadas cron no pasan ninguna carga útil) y devolvemos el resultado de texto de la llamada a función.

Cuando miro los registros de mi función en el registro de Stackdriver, veré cada 10 minutos que se ha llamado a la función, y aparece un mensaje que dice ¡No hay ningún mensaje definido! (Porque mi llamada cron de App Engine no envía ningún mensaje) .)

Más información

Para esta articulo, se inspiro en esta publicación de Valerii Iatsko, que muestra cómo usar App Engine para Python para programar llamadas a Cloud Functions.

Puede obtener más información sobre la configuración cron de App Engine Java en la documentación.

Si también está interesado en Apache Groovy y Gaelyk, puede consultar:
  • La documentación de Apache Groovy
  • La documentación del framework Gaelyk (y en particular todos los buenos accesos directos ofrecidos para simplificar el uso de App Engine)