Se usó la API de Cloud Translation para traducir esta página.

Migra desde una VM de Linux con la CLI de Migrate to Containers

En esta guía de inicio rápido, crearás una instancia de máquina virtual (VM) de Compute Engine y, luego, usarás la CLI de Migrate to Containers para migrar la VM a Google Kubernetes Engine (GKE).

Antes de comenzar

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Nota: Si no planeas conservar los recursos creados durante este procedimiento, crea un proyecto en lugar de elegir un proyecto existente. Cuando termines, puedes borrar el proyecto si quitas todos los recursos asociados con él.

Ir al selector de proyectos
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.
Habilita la API de Compute Engine.

Habilitar la API de Compute Engine
Habilita la API de GKE:
Habilita la API de GKE

Crea una VM de Compute Engine con un servidor web para usar como VM de origen

En esta sección, se describe cómo crear una VM de Compute Engine que entrega una página web Hello World!, que puedes usar para realizar pruebas después de que se complete la migración.

En la consola de Google Cloud, haz clic en Activar Cloud Shell.
Ir a la consola de Google Cloud

Crea una VM:

gcloud compute instances create quickstart-source-vm \
  --zone=us-central1-a --machine-type=e2-medium  \
  --subnet=default --scopes="cloud-platform" \
  --tags=http-server,https-server --image=ubuntu-2204-jammy-v20240208 \
  --image-project=ubuntu-os-cloud --boot-disk-size=10GB --boot-disk-type=pd-standard \
  --boot-disk-device-name=quickstart-source-vm

Espera unos minutos a que finalice la creación de la VM.

Crea una regla de firewall que permita solicitudes a la instancia a través de HTTP:

gcloud compute 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

Ve a la página Instancias de VM.

Ir a Instancias de VM
Para conectarte a la VM quickstart-source-vm, busca la fila de la VM y, luego, haz clic en SSH.

La conexión se establece en una pestaña nueva.
En la pestaña del comando quickstart-source-vm, instala 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.

En la misma pestaña, reemplaza la página web predeterminada de Apache Web Server por una nueva:

echo '<!doctype html><html><body><h1>Hello World!</h1></body></html>' | sudo tee /var/www/html/index.html

Regresa a la página Instancias de VM y copia la dirección IP externa que se muestra para quickstart-source-vm.
Pega la dirección IP de la VM en la barra de direcciones del navegador. Agrega el prefijo http://.

Aparecerá la página Hello World!.

Crea una VM de Compute Engine para usarla como máquina local

En esta sección, crearás una VM de Linux que puedes usar como máquina local para realizar las diferentes operaciones de Migrate to Containers a fin de migrar la VM de origen.

En la consola de Google Cloud, haz clic en Activar Cloud Shell.
Ir a la consola de Google Cloud

Crea una VM:

gcloud compute instances create quickstart-local-vm \
  --zone=us-central1-a --machine-type=e2-medium  \
  --subnet=default --scopes="cloud-platform" \
  --tags=http-server,https-server --image=ubuntu-2204-jammy-v20240208 \
  --image-project=ubuntu-os-cloud --boot-disk-size=50GB --boot-disk-type=pd-standard \
  --boot-disk-device-name=quickstart-local-vm

Espera unos minutos a que finalice la creación de la VM.

Crea un clúster de GKE

En esta sección, crearás un clúster de GKE en Google Cloud, en el que implementarás la carga de trabajo alojada en contenedores más adelante en esta guía de inicio rápido.

En Cloud Shell, crea un clúster de Kubernetes nuevo:

gcloud container clusters create quickstart-cluster \
  --zone=us-central1-a --machine-type=e2-medium \
  --image-type=ubuntu_containerd --num-nodes=1 \
  --logging=SYSTEM,WORKLOAD,API_SERVER,SCHEDULER,CONTROLLER_MANAGER

Espera unos minutos a que finalice la creación del clúster.

Prepara la VM local para realizar la migración

Ve a la página Instancias de VM.

Ir a Instancias de VM
Para conectarte a la VM quickstart-local-vm, busca la fila de la VM y, luego, haz clic en SSH.

La conexión se establece en una pestaña nueva.

En la pestaña de comandos quickstart-local-vm, instala Google Cloud CLI:

# Import the Google Cloud public key.
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/cloud.google.gpg

# Add the gcloud CLI distribution URI as a package source
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list

# Update and install gcloud
sudo apt-get update && sudo apt-get install google-cloud-cli

# Get started
gcloud init

Para completar la configuración de gcloud CLI, sigue las instrucciones que aparecen en la pestaña del comando quickstart-local-vm:

A fin de seleccionar la cuenta que se usará para realizar varias operaciones, ingresa 1.
Para seleccionar el proyecto en el que creaste la VM, ingresa 1.
Para omitir la configuración de una región y una zona predeterminadas, ingresa n.

Instala Docker y permite que el usuario no raíz ejecute contenedores:

# Download the convenience script
curl -fsSL https://get.docker.com -o install-docker.sh

# Install Docker
sudo sh install-docker.sh

# Allow the non-root user to access Docker
sudo usermod -aG docker $USER

# Activate the group changes
newgrp docker

Instala Skaffold:

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64 && \
sudo install skaffold /usr/local/bin/

Descarga la CLI de Migrate to Containers:

curl -O "https://m2c-cli-release.storage.googleapis.com/$(curl -s https://m2c-cli-release.storage.googleapis.com/latest)/linux/amd64/m2c"
chmod +x ./m2c

Migra la VM de origen

Por lo general, una migración implica tres pasos: copiar el sistema de archivos de VM de origen, analizar el sistema de archivos para crear un plan de migración y generar los artefactos de migración.

En las siguientes secciones, se describe cómo usar la CLI de Migrate to Containers para migrar la VM de origen con la VM local de Linux.

Copia el sistema de archivos de la VM de origen

Cuando copias un sistema de archivos de VM de origen, la CLI de Migrate to Containers usa filtros predeterminados para reducir el tamaño del sistema de archivos copiado. Sin embargo, a fin de que el servidor Apache esté disponible para iniciarse, el servidor necesita el directorio /var/log, que se quita mediante los filtros predeterminados.

En esta sección, se describe cómo editar los filtros predeterminados para garantizar que /var/log/* se copie con el sistema de archivos de la VM de origen.

En la pestaña del comando quickstart-local-vm, obtén una lista de los filtros predeterminados de Migrate to Containers en un archivo llamado filters.txt:
```
./m2c copy default-filters > filters.txt
```
Para editar los filtros predeterminados, haz lo siguiente:
1. Abre el archivo filters.txt en un editor de texto:
```
vi filters.txt
```
2. Para realizar cambios en el archivo, presiona i.
3. Quita la siguiente declaración:
```
- /var/log/*
```
4. Para guardar el archivo y salir del editor de texto, presiona Esc y, luego, ingresa :wq.
Copia el sistema de archivos de la máquina de origen:
```
./m2c copy gcloud \
  --project PROJECT_ID --zone us-central1-a \
  --vm-name quickstart-source-vm --output quickstart-vm-filesystem \
  --filters filters.txt
```
Reemplaza PROJECT_ID por el ID del proyecto.

Hay una copia del sistema de archivos de la máquina de origen disponible en el directorio quickstart-vm-filesystem.

Crea el plan de migración

En la pestaña del comando quickstart-local-vm, crea el plan de migración
```
./m2c analyze \
  --source quickstart-vm-filesystem --plugin linux-vm-container \
  --output analysis-output
```
Una vez completado el análisis, se crea un directorio nuevo llamado analysis-output que contiene el plan de migración, config.yaml.

Genera los artefactos de migración

En la pestaña del comando quickstart-local-vm, genera los artefactos de migración:
```
./m2c generate --input analysis-output --output migration-artifacts
```
Los artefactos de migración generados se agregan al directorio migration-artifacts.

Implementa la carga de trabajo migrada

En esta sección, implementarás la carga de trabajo migrada de tu VM local quickstart-local-vm al clúster de GKE que se ejecuta en Google Cloud.

En la pestaña del comando quickstart-local-vm, instala el complemento gke-gcloud-auth-plugin:
```
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
```
Instala kubectl:
```
sudo apt-get install kubectl
```

Conéctate al clúster quickstart-cluster:

gcloud container clusters get-credentials quickstart-cluster \
  --zone us-central1-a --project PROJECT_ID

Abre la carpeta migration-artifacts:
```
cd migration-artifacts
```

Para exponer la carga de trabajo a Internet, agrega un nuevo servicio LoadBalancer en el archivo deployment_spec.yaml. Para editar el archivo deployment_spec.yaml, haz lo siguiente:

Abre el archivo deployment_spec.yaml en un editor de texto:
```
vi deployment_spec.yaml
```
Para realizar cambios en el archivo, presiona i.

Ubica el objeto Service con el nombre linux-system. Se verá parecido al siguiente ejemplo:

apiVersion: v1
kind: Service
metadata:
  labels:
    anthos-migrate.cloud.google.com/type: linux-container
    migrate-for-anthos-optimization: "true"
    migrate-for-anthos-version: m2c-cli-1.2.2
  name: linux-system
spec:
  clusterIP: None
  selector:
    app: linux-system
  type: ClusterIP

Agrega otro objeto Service llamado hello-service justo después de linux-system:

apiVersion: v1
kind: Service
metadata:
  labels:
    anthos-migrate.cloud.google.com/type: linux-container
    migrate-for-anthos-optimization: "true"
    migrate-for-anthos-version: m2c-cli-1.2.2
  name: linux-system
spec:
  clusterIP: None
  selector:
    app: linux-system
  type: ClusterIP
---
# Add the hello-service object
apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  selector:
    app: linux-system
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Para guardar el archivo y salir del editor de texto, presiona Esc y, luego, ingresa :wq.

Implementa la VM migrada:
```
skaffold run -d eu.gcr.io/PROJECT_ID
```
Obtén la dirección IP externa de la VM migrada:
```
kubectl get service hello-service
```

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

NAME            TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
hello-service   LoadBalancer   10.23.241.124   EXTERNAL_IP   80:32611/TCP   5m4s

Para verificar si la migración se realizó de forma correcta, abre una pestaña nueva del navegador y visita la página web en la dirección IP externa.
```
http://EXTERNAL_IP
```
Asegúrate de usar HTTP y no HTTPS.
Si ves el texto Hello World! en la pantalla, la migración de VM se realizó de forma correcta.

Si no puedes acceder a la carga de trabajo migrada, consulta cómo solucionar problemas conocidos.

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

Borra el clúster de GKE

En la consola de Google Cloud, ve a la página de GKE.
Ir a GKE
Selecciona quickstart-cluster y, luego, haz clic en Borrar.
Cuando se te solicite confirmación, haz clic en Borrar de nuevo.

Borra las VMs

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en el nombre quickstart-source-vm.
En la parte superior de la página de detalles de la instancia, haz clic en Borrar.
Haz clic en el nombre quickstart-local-vm.
En la parte superior de la página de detalles de la instancia, haz clic en Borrar.

¿Qué sigue?

Obtén información sobre cómo agrupar en lotes el descubrimiento de invitados y la recopilación de datos.
Para obtener información sobre cómo migrar una aplicación más compleja, consulta el instructivo sobre cómo migrar una aplicación de framework de Spring disponible en el repositorio de GitHub de Migrate to Containers.