Esta página se ha traducido con Cloud Translation API.

Migrar una VM de Linux con la CLI de Migrate to Containers

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

Antes de empezar

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

Nota: Si no tienes la intención de guardar los recursos que obtendrás a lo largo de este procedimiento, crea un proyecto en lugar de seleccionar uno disponible. Después de completar estos pasos, podrás eliminar el proyecto y, con él, todos los recursos asociados.

Ir al selector de proyectos
Comprueba que la facturación esté habilitada en tu Google Cloud proyecto. Consulta cómo comprobar si la facturación está habilitada en un proyecto.
Habilita la API Compute Engine.

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

Crear una VM de Compute Engine con un servidor web para usarla como VM de origen

En esta sección se describe cómo crear una VM de Compute Engine que sirva una página web Hello World! que puedas usar para hacer pruebas una vez que se haya completado la migración.

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

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 se complete la creación de la VM.

Crea una regla de cortafuegos que permita las 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 haz clic en SSH.

La conexión se establece en una pestaña nueva.
En la pestaña de comandos 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 automáticamente el servidor Apache.

En la misma pestaña, sobrescribe la página web predeterminada del servidor web Apache con una página nueva:

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

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

Aparecerá la página Hello World! (¡Hola, mundo!).

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

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

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

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 se complete la creación de la VM.

Crear un clúster de GKE

En esta sección, crearás un clúster de GKE en Google Cloud, donde desplegarás tu carga de trabajo en contenedores más adelante en esta guía de inicio rápido.

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

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 se cree el clúster.

Preparar 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 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 de comandos quickstart-local-vm:

Para seleccionar la cuenta que quieres usar para realizar varias operaciones, introduce 1.
Para seleccionar el proyecto en el que has creado la VM, introduce 1.
Para saltarte la configuración de una región y una zona predeterminadas, introduce 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

Migrar la VM de origen

Una migración suele constar de tres pasos: copiar el sistema de archivos de la 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 tu VM de Linux local.

Copiar el sistema de archivos de la VM de origen

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

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

En la pestaña de comandos 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, siga estos pasos:
1. Abre el archivo filters.txt en un editor de texto:
```
vi filters.txt
```
2. Para hacer cambios en el archivo, pulsa i.
3. Elimina la siguiente afirmación:
```
- /var/log/*
```
4. Para guardar el archivo y salir del editor de texto, pulsa Esc y, a continuación, introduce :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
```
Sustituye PROJECT_ID con el ID del proyecto.

En el directorio quickstart-vm-filesystem se encuentra una copia del sistema de archivos del equipo de origen.

Crear el plan de migración

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

Generar los artefactos de migración

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

Desplegar la carga de trabajo migrada

En esta sección, desplegarás la carga de trabajo migrada desde tu máquina virtual local quickstart-local-vm al clúster de GKE que se ejecuta enGoogle Cloud.

En la pestaña de comandos quickstart-local-vm, instala el complemento gke-gcloud-auth-plugin:
```
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
```
Instalar 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, añade 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 hacer cambios en el archivo, pulsa i.

Busca el objeto Service con el nombre linux-system. Se parece a lo siguiente:

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

Añade 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, pulsa Esc y, a continuación, introduce :wq.

Despliega 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 has añadido.

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

Para comprobar si la migración se ha realizado correctamente, abre una nueva pestaña 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, significa que la migración de la máquina virtual se ha completado correctamente.

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

Limpieza

Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos utilizados en esta página, sigue estos pasos.

Elimina el clúster de GKE

En la Google Cloud consola, ve a la página GKE.
Ir a GKE
Selecciona quickstart-cluster y, a continuación, haz clic en Eliminar.
Cuando se te solicite confirmación, vuelve a hacer clic en Eliminar.

Eliminar 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 Eliminar.
Haz clic en el nombre quickstart-local-vm.
En la parte superior de la página de detalles de la instancia, haz clic en Eliminar.

Siguientes pasos

Consulte cómo procesar por lotes la detección de invitados y la recogida de datos.
Para saber cómo migrar una aplicación más compleja, consulta el tutorial sobre cómo migrar una aplicación del framework Spring, disponible en el repositorio de GitHub Migrate to Containers.