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

Adapta los sistemas operativos para Google Cloud

En este documento, se describe cómo adaptar las imágenes del sistema operativo (SO) enGoogle Cloud para usar las imágenes del SO empresarial para las que tienes licencias.

Google Cloud proporciona imágenes de SO para Debian, Ubuntu LTS, Rocky Linux y Container-Optimized OS. Si quieres usar alguna de estas imágenes proporcionadas, crea una instancia y selecciona la imagen que quieras usar durante la creación de la instancia.

Si tienes una licencia para un SO empresarial para el que Google Cloud no se proporciona una imagen de SO, como Windows, Red Hat Enterprise Linux (RHEL) o SUSE Linux Enterprise Server (SLES), usa la secuencia de comandos que se proporciona en este documento para adaptar una imagen para usarla con tu licencia. La secuencia de comandos instala los controladores necesarios para que uses tu imagen y crees instancias en Google Cloud.

Antes de comenzar

Instala el procesador de línea de comandos de jq.
Si aún no lo hiciste, sube un disco que contenga la imagen de SO que deseas usar a un bucket de Cloud Storage.
Confirma que tienes los permisos necesarios para crear imágenes personalizadas.
Si aún no lo hiciste, configura la autenticación. La autenticación verifica tu identidad para acceder a los Google Cloud servicios y las APIs. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:
Select the tab for how you plan to use the samples on this page:
gcloud
1. Instala Google Cloud CLI. Después de la instalación, inicializa Google Cloud CLI ejecutando el siguiente comando:
  gcloud init
  Si usas un proveedor de identidad externo (IdP), primero debes acceder a gcloud CLI con tu identidad federada.
  
  Nota: Si ya instalaste gcloud CLI, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.
2. Set a default region and zone.
REST

Para usar las muestras de la API de REST en esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a gcloud CLI.
Para obtener más información, consulta Autentícate para usar REST en la documentación de autenticación de Google Cloud .

Secuencia de comandos de adaptación del SO

Para ayudarte a adaptar imágenes para Google Cloud, Google Cloud proporciona una secuencia de comandos que completa los siguientes pasos:

Crea una instancia con el disco de Cloud Storage y ejecuta la herramienta de adaptación del SO en el disco de la instancia. Este proceso instala los controladores necesarios para que la imagen de SO funcione en Google Cloud.
Extrae el informe de adaptación del SO y copia los archivos de salida en tu máquina local. Este informe proporciona información sobre los resultados del proceso de adaptación, junto con detalles sobre el SO detectado. Si la secuencia de comandos no se ejecuta correctamente, el informe proporciona errores, advertencias y elementos de acción para corregir los problemas de adaptación.
Crea una imagen a partir del disco de la instancia. Luego, puedes usar esta imagen para crear instancias en Google Cloud.
Borra la instancia y el disco que se crearon durante este proceso. En este paso, se limpian los recursos innecesarios de tu proyecto.

La siguiente secuencia de comandos adapta imágenes para usarlas en Google Cloud:

Secuencia de comandos completa de adaptación del SO

#!/usr/bin/env bash

# Sets variables

set -e
set -x
set -o pipefail

UNIQUE_ID=''
TPC_PREFIX=''
ZONE=''
PROJECT=''
INPUT_IMAGE=''
INPUT_DISK=''
IMAGE_NAME=''
ADAPTATION_INSTANCE_TYPE='c3-highcpu-4' # needs to support nested virtualization



usage() {
  echo ""
  echo "Usage:"
  echo "       $0 -g  -o -z -t  -p "
  echo ""
  echo ""
  echo "Parameters:"
  echo "       -i  OR -d  OR -g "
  echo "       -o "
  echo "       -z "
  echo "       -t "
  echo "       -p "
  echo "       -h (help)"
  echo ""
}

while getopts ":i:d:g:o:z:t:p:h" opt; do
  case "${opt}" in
    i)
      INPUT_IMAGE="${OPTARG}"
      ;;
    d)
      INPUT_DISK="${OPTARG}"
      ;;
    g)
      INPUT_GCS_OBJECT="${OPTARG}"
      ;;
    o)
      IMAGE_NAME="${OPTARG}"
      ;;
    z)
      ZONE="${OPTARG}"
      ;;
    t)
      TPC_PREFIX="${OPTARG}"
      ;;
    p)
      PROJECT="${OPTARG}"
      ;;
    h)
      echo "$0 help:"
      usage
      exit 0
      ;;
    *)
      echo "Unknown arg -${opt} ${OPTARG}"
      usage
      exit 1
      ;;
  esac
done
shift $((OPTIND-1))

# Defines errors

if [[ -n "${INPUT_IMAGE}" && -n "${INPUT_DISK}" ]] ||
   [[ -n "${INPUT_IMAGE}" && -n "${INPUT_GCS_OBJECT}" ]] ||
   [[ -n "${INPUT_DISK}" && -n "${INPUT_GCS_OBJECT}" ]]; then
  echo "Only one of -i, -d, or -g must be specified"
  usage
  exit 1
fi

if [[ -z "${IMAGE_NAME}" ]]; then
  echo "The name of the image must be specified"
  usage
  exit 1
fi

if [[ -z "${ZONE}" ]]; then
  echo "Zone must be specified"
  usage
  exit 1
fi

if [[ -z "${TPC_PREFIX}" ]]; then
  echo "TPC prefix must be specified"
  usage
  exit 1
fi

if [[ -z "${PROJECT}" ]]; then
  echo "Project must be specified"
  usage
  exit 1
fi

# Creates disk

OS_ADAPTATION_IMAGE="projects/${TPC_PREFIX}:v2v-community/global/images/family/v2v-tpc-stable"

if [[ -z "${UNIQUE_ID}" ]]; then
  UNIQUE_ID=$(head /dev/urandom | tr -dc a-z0-9 | head -c4)
fi

if [[ -n "${INPUT_IMAGE}" ]]; then
  DISK_ID="${IMAGE_NAME}-disk-${UNIQUE_ID}"
  echo "Creating disk ${DISK_ID} from image ${INPUT_IMAGE}..."
  gcloud compute disks create "${DISK_ID}" --zone="${ZONE}" --image "${INPUT_IMAGE}"
elif [[ -n "${INPUT_GCS_OBJECT}" ]]; then
  DISK_ID="${IMAGE_NAME}-disk-${UNIQUE_ID}"

  echo "Creating disk ${DISK_ID} from GCS object ${INPUT_GCS_OBJECT}..."
  CURL_OUTPUT=$(curl \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H 'Content-Type: application/json' \
    -X POST  \
    "https://compute.googleapis.com/compute/v1/projects/${TPC_PREFIX}:${PROJECT}/zones/${ZONE}/disks" \
    -d '{"name":"'"${DISK_ID}"'", "sourceStorageObject":"'"${INPUT_GCS_OBJECT}"'"}')
  OPERATION_ID=$(jq -r '.name' <<< "${CURL_OUTPUT}")
  while ! gcloud compute operations describe --zone "${ZONE}" --format=json \
    "${OPERATION_ID}" | jq -e '.status == "DONE"' >/dev/null; do
    sleep 5
  done
elif [[ -n "${INPUT_DISK}" ]]; then
  DISK_ID="${INPUT_DISK}"
fi

QUERY_PATH='v2v/report'
DEVICE_NAME="dev-${UNIQUE_ID}"
OUTPUT_DIR='/var/v2v'
STARTUP_SCRIPT="docker run --privileged -v /dev:/dev -v ${OUTPUT_DIR}:${OUTPUT_DIR} v2v-tpc -vv --log file=${OUTPUT_DIR}/output.log,level=trace --report file=${OUTPUT_DIR}/report.json --report file=http://metadata.google.internal/computeMetadata/v1/instance/guest-attributes/${QUERY_PATH},headers=Metadata-Flavor=Google --license=byol --in-place --drive file=/dev/disk/by-id/google-${DEVICE_NAME},format=raw"

# Creates instance and runs adaptation tool on disk

echo "Adapting disk ${DISK_ID}"

INSTANCE="os-adaptation-instance-${UNIQUE_ID}"
gcloud compute instances create "${INSTANCE}" \
  --zone="${ZONE}" \
  --machine-type="${ADAPTATION_INSTANCE_TYPE}" \
  --enable-nested-virtualization \
  --metadata="^@@@^enable-guest-attributes=TRUE@@@startup-script=${STARTUP_SCRIPT}" \
  --create-disk="auto-delete=yes,boot=yes,image=${OS_ADAPTATION_IMAGE}" \
  --disk="name=${DISK_ID},auto-delete=no,device-name=${DEVICE_NAME}"


# Retrieves report

while [[ -z "${REPORT}" ]]; do
  sleep 5
  set +e
  REPORT=$(gcloud compute instances get-guest-attributes "${INSTANCE}" \
    --zone="${ZONE}" \
    --query-path="${QUERY_PATH}" \
    --format='value(value)') 2>/dev/null
  echo -n '.'
  set -e
done
echo "Operating System adaptation report:"
jq . <<< "${REPORT}"

gcloud compute scp --recurse "${INSTANCE}:${OUTPUT_DIR}" "$(pwd)"
echo "Output file: $(pwd)/v2v/output.log, Report file: $(pwd)/v2v/report.json"

echo "Deleting ${INSTANCE}..."
gcloud compute instances delete "${INSTANCE}" --zone="${ZONE}" --quiet

if jq --exit-status '.status != "SUCCESS"' <<< "${REPORT}" >/dev/null; then
  echo "Operating System adaptation failed"
  exit 1
fi

# Creates image

echo "Operating System adaptation successful, creating image..."

IMAGE="image-${UNIQUE_ID}"
gcloud compute images create "${IMAGE}" \
  --source-disk-zone="${ZONE}" \
  --guest-os-features="$(jq --raw-output '.guest_os_features | join(",")' <<< "${REPORT}")" \
  --source-disk="${DISK_ID}"

if [[ -z "${INPUT_DISK}" ]]; then
  gcloud compute disks delete "${DISK_ID}" --zone="${ZONE}" --quiet
fi

echo "Adapted image: ${IMAGE}"

Ejecuta la secuencia de comandos de adaptación del SO

Para adaptar tu imagen de SO a Google Cloud, haz lo siguiente:

Crea una secuencia de comandos de shell.
Copia el script de adaptación del SO y pégalo en tu archivo de secuencia de comandos de shell.
Ejecuta tu secuencia de comandos de shell con las siguientes marcas:
```
SCRIPT_NAME \
 -g 'INPUT_GCS_OBJECT' \
 -o 'IMAGE_NAME' \
 -z 'ZONE' \
 -p 'PROJECT' \
 -t 'TPC_PREFIX'
```
Reemplaza lo siguiente:
- SCRIPT_NAME: Es el nombre del archivo de secuencia de comandos de adaptación del SO.
- INPUT_GCS_OBJECT: Es la ruta de acceso al disco en tu bucket de Cloud Storage.
- IMAGE_NAME: Es el nombre de la imagen adaptada.
- ZONE: Es la zona de la imagen adaptada.
- PROJECT: El ID de tu proyecto de Google Cloud
- TPC_PREFIX: Es un prefijo que se usa para los nombres de tus recursos.

Después de que la secuencia de comandos se ejecute correctamente, se imprimirá el siguiente mensaje:

Adapted image: IMAGE_NAME

¿Qué sigue?

Crea una instancia a partir de tu imagen.

Adapta los sistemas operativos para Google Cloud Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

gcloud

REST

Secuencia de comandos de adaptación del SO

Secuencia de comandos completa de adaptación del SO

Ejecuta la secuencia de comandos de adaptación del SO

¿Qué sigue?

Adapta los sistemas operativos para Google Cloud