Guía de inicio rápido

En esta guía de inicio rápido, crearás una máquina virtual (VM) simple de Compute Engine y, luego, usarás Migrate for Anthos para migrar la VM a GKE.

Antes de comenzar

Habilita la compatibilidad con Compute Engine

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página Selector de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita la API de Compute Engine.

    Habilita la API

Habilita y configura GKE

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

  • Usa gcloud init si deseas ver una explicación sobre cómo configurar parámetros predeterminados.
  • Usa gcloud config para establecer el ID, la zona y la región del proyecto de manera individual.

Usa gcloud init

  1. Ejecuta gcloud init y sigue las instrucciones:

    gcloud init

    Si usas SSH en un servidor remoto, usa la marca --console-only para evitar que el comando abra un navegador:

    gcloud init --console-only
  2. Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
  3. Crea una configuración nueva o selecciona una existente.
  4. Elige un proyecto de Google Cloud.
  5. Elige una zona predeterminada de Compute Engine.

Usa gcloud config

  • Establece tu ID del proyecto predeterminado:
    gcloud config set project project-id
  • Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
    gcloud config set compute/zone compute-zone
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada:
    gcloud config set compute/region compute-region
  • Actualiza gcloud a la versión más reciente:
    gcloud components update

Crea una VM con un servidor web

En los siguientes pasos, crearás una VM simple de Compute Engine que entrega una página web “Hello World!”. Tener la página te permite realizar una prueba después de la migración.

  1. Ejecuta el siguiente comando para crear la instancia de VM que migrarás.

    Especifica una zona que será la misma en la que crees un GKE más adelante en este tema.

    gcloud beta compute  --project=project-id instances create \
      quickstart-instance  --zone=zone --machine-type=n1-standard-1 \
      --subnet=default --scopes="cloud-platform" \
      --tags=http-server,https-server --image=ubuntu-minimal-1604-xenial-v20200317 \
      --image-project=ubuntu-os-cloud --boot-disk-size=10GB --boot-disk-type=pd-standard \
      --boot-disk-device-name=quickstart-instance
    
  2. Ejecuta el siguiente comando para crear una regla de firewall que permita solicitudes a la instancia a través de HTTP.

    gcloud compute --project=project-id firewall-rules create default-allow-http \
      --direction=INGRESS --priority=1000 --network=default --action=ALLOW \
      --rules=tcp:80 --source-ranges=0.0.0.0/0 --target-tags=http-server
    
  3. En Google Cloud Console, ve a la página Instancias de VM.

    Ir a la página Instancias de VM

  4. En la lista de instancias de máquina virtual, haz clic en SSH en la fila de la instancia que acabas de crear.

    Para obtener más información sobre cómo conectarte a través de SSH, consulta Conéctate a instancias.

  5. En la ventana de comandos de quickstart-instance, usa el administrador de paquetes para instalar el paquete apache2.

    sudo apt-get update && sudo apt-get install apache2 -y
    

    Después de instalar Apache, el sistema operativo inicia el servidor Apache de forma automática.

  6. En la misma ventana de comando, reemplaza la página web predeterminada de Apache Web Server por el siguiente comando:

    echo '<!doctype html><html><body><h1>Hello World!</h1></body></html>' | sudo tee /var/www/html/index.html
    
  7. En la página Instancias de VM, ubica la fila de la instancia que creaste y copia la dirección IP externa.

  8. Pega la dirección IP de la instancia en la barra de direcciones del navegador. Agrega el prefijo http://.

    Deberías ver la página “Hello World!”.

  9. En la página Instancias de VM, selecciona la casilla de verificación que se encuentra en el extremo izquierdo de la fila de la instancia que creaste.

  10. En la parte superior de la página, haz clic en el botón Detener para detener la VM.

Crea un clúster de procesamiento y, luego, instala Migrate for Anthos

En los siguientes pasos, crearás un clúster de GKE que usarás como clúster de procesamiento. También instalarás Migrate for Anthos y ejecutarás la migración.

  1. En Cloud Shell, usa el siguiente comando para crear un nuevo clúster de Kubernetes y usarlo como un clúster de procesamiento.

    Cuando especifiques el valor machine-type, asegúrate de especificar un tipo de máquina que tenga al menos 15 GB de memoria.

    gcloud container clusters create migration-processing --scopes="cloud-platform" \
      --project=project-id --zone=zone --machine-type n1-standard-4 \
      --image-type ubuntu --num-nodes 1 --enable-stackdriver-kubernetes \
      --subnetwork "projects/project-id/regions/region/subnetworks/default"
    
  2. Conéctate al clúster.

    gcloud container clusters get-credentials migration-processing \
      --zone zone --project project-id
    
  3. Configura los componentes de Migrate for Anthos en el clúster de procesamiento.

    migctl setup install
    
  4. Valida la instalación de Migrate for Anthos.

    Usa el comando migctl doctor para confirmar una implementación exitosa.

    migctl doctor
    

    Es posible que el comando demore más de un minuto en mostrar el resultado correcto.

    [✓] Deployment
    

Migra la VM

En los siguientes pasos, crearás un plan de migración con los detalles de la migración y, luego, lo usarás para migrar la VM.

  1. Especifica la fuente de migración como una VM de Compute Engine. Esto agregará la especificación de origen al plan de migración.

    migctl source create ce quickstart-source --project project-id --zone zone
    
  2. Crea una migración.

    Con este comando, se crea un plan de migración que define qué migrar.

    migctl migration create my-migration --source quickstart-source \
      --vm-id quickstart-instance --intent Image
    
  3. Guarda el plan de migración que acabas de editar.

  4. Migra la VM con el plan de migración para guiar la migración.

    Esto migrará la VM y generará artefactos que puedes usar para implementar la carga de trabajo.

    migctl migration generate-artifacts my-migration
    
  5. Después de que comience la migración, verifica su estado hasta que finalice.

    La migración puede tardar varios minutos. Si verificas el estado durante este tiempo, se mostrará el estado actual de la migración.

    migctl migration status my-migration
    

    Cuando se complete la migración, deberías ver un mensaje como el que se muestra a continuación:

    migctl migration status my-migration
    NAME           PROCESS              STATE       STATUS      PROGRESS   AGE
    my-migration   generate-artifacts   completed   COMPLETED   [15/15]    7m25s
    

Implementa la carga de trabajo migrada

En los siguientes pasos, obtendrás los artefactos de implementación que generaste durante la migración y, luego, los usarás para implementar la carga de trabajo que se migró al clúster. Como último paso, confirmarás que la página web “Hello World!” está disponible desde la app migrada.

  1. Una vez completada la migración, obtén los artefactos YAML generados.

    migctl migration get-artifacts my-migration
    

    El comando descarga los archivos que se generaron durante la migración:

    • deployment_spec.yaml: El archivo YAML que configura la carga de trabajo.
    • Dockerfile: El Dockerfile que se usa para compilar la imagen de la VM migrada.
    • migration.yaml: Una copia del plan de migración.
  2. Abre el archivo deployment_spec.yaml y ubica el objeto Service con el nombre app-quickstart-instance.

  3. Debajo de la definición Service, pega otro Service que exponga el puerto 80 para acceder al servidor web a través de HTTP y, luego, guarda el archivo.

    Pega el código destacado para que tengas lo que se muestra a continuación en las especificaciones de implementación.

    apiVersion: v1
    kind: Service
    metadata:
      creationTimestamp: null
      name: app-quickstart-instance
    spec:
      clusterIP: None
      selector:
        app: app-quickstart-instance
      type: ClusterIP
    status:
      loadBalancer: {}
    
    ---
    
    
    apiVersion: v1
    kind: Service
    metadata:
      name: hello-service
    spec:
      selector:
        app: app-quickstart-instance
      ports:
        - protocol: TCP
          port: 80
          targetPort: 80
      type: LoadBalancer
    
    

  4. Aplica la especificación de implementación YAML para implementar la carga de trabajo.

    kubectl apply -f deployment_spec.yaml
    

    Es posible que la implementación tarde unos minutos en completarse.

  5. Busca una dirección IP externa.

    kubectl get service hello-service
    

    Cuando el servidor web esté listo, verás una dirección IP externa para el hello-service que agregaste.

    kubectl get service hello-service
    NAME            TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
    hello-service   LoadBalancer   10.23.241.124   ##.##.###.##   80:32611/TCP   5m4s
    
  6. Para probar la migración, abre un navegador y visita la página web en la dirección IP externa (asegúrate de usar HTTP en lugar de HTTPS).

    http://##.##.###.##
    

Puedes ejecutar comandos bash en el contenedor con la carga de trabajo migrada. Para obtener más información, consulta el tema Solución de problemas.

Realiza una limpieza

A fin de evitar cargos innecesarios de Google Cloud, usa Google Cloud Console para borrar tu proyecto si no lo necesitas.

Próximos pasos