Adapta los sistemas operativos para Cloud de Confiance by S3NS

En este documento, se describe cómo adaptar imágenes del sistema operativo (SO) en Cloud de Confiance by S3NS para usar las imágenes de SO empresariales para las que tienes licencias.

Cloud de Confiance by S3NS proporciona imágenes de SO para Debian, Ubuntu LTS, Rocky Linux y Container-Optimized OS. Si quieres usar alguna de estas imágenes proporcionadas, continúa para crear una instancia y selecciona la imagen que deseas usar durante la creación de la instancia.

Si tienes una licencia para un SO empresarial para el que Cloud de Confiance by S3NS no 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 para crear instancias en Cloud de Confiance by S3NS.

Antes de comenzar

• Instala el jq procesador de línea de comandos.
• 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 Cloud de Confiance by S3NS 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:

  Selecciona la pestaña según cómo planeas usar las muestras en esta página:

  gcloud

  1. Instala Google Cloud CLI y, luego, accede a gcloud CLI con tu identidad federada. Después de acceder, inicializa Google Cloud CLI con el siguiente comando:

     gcloud init

• Configura una región y una zona predeterminadas.

REST

Para usar las muestras de la API de REST incluidas en esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la gcloud CLI.

Instala Google Cloud CLI y, luego, accede a gcloud CLI con tu identidad federada.

Para obtener más información, consulta Autentícate para usar REST en la documentación de autenticación de. Cloud de Confiance

Sistemas operativos compatibles

El proceso de secuencia de comandos de adaptación del SO, que usa la herramienta v2v-tpc, solo sirve para adaptar los siguientes sistemas operativos de Bring Your Own License (BYOL):

• Windows Server 2016, 2019, 2022, 2025
• Red Hat Enterprise Linux (RHEL) 8.x, 9.x, 10.x
• SUSE Linux Enterprise Server (SLES) 12.x, 15.x

Para ejecutar otros sistemas operativos, como AlmaLinux o Fedora Cloud, usa una de las imágenes de SO disponibles públicamente.

Secuencia de comandos de adaptación del SO

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

1. 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 que son necesarios para que la imagen de SO funcione en Cloud de Confiance by S3NS.
2. 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.
3. Crea una imagen a partir del disco de la instancia. Luego, puedes usar esta imagen para crear instancias en Cloud de Confiance by S3NS.
4. Borra la instancia y el disco que se crearon durante este proceso. Este paso limpia los recursos innecesarios de tu proyecto.

La siguiente secuencia de comandos adapta imágenes para usarlas en Cloud de Confiance by S3NS:

#!/usr/bin/env bash

# Sets variables

set -e
set -x
set -o pipefail

UNIQUE_ID=''
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}"
      ;;
    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 "${PROJECT}" ]]; then
  echo "Project must be specified"
  usage
  exit 1
fi

# Creates disk

OS_ADAPTATION_IMAGE="projects/s3ns-system: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.s3nsapis.fr/compute/v1/projects/s3ns-system:${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 la imagen de SO para Cloud de Confiance by S3NS, haz lo siguiente:

1. Crea una secuencia de comandos de shell.
2. Copia la secuencia de comandos de adaptación del SO y pégala en el archivo de secuencia de comandos de shell.

3. Ejecuta la secuencia de comandos de shell con los siguientes marcadores:

   SCRIPT_NAME \
    -g 'INPUT_GCS_OBJECT' \
    -o 'IMAGE_NAME' \
    -z 'ZONE' \
    -p 'PROJECT'

   Reemplaza lo siguiente:

   • SCRIPT_NAME: el nombre del archivo de secuencia de comandos de adaptación del SO
   • INPUT_GCS_OBJECT: la ruta de acceso al disco en tu bucket de Cloud Storage
   • IMAGE_NAME: el nombre de la imagen adaptada
   • ZONE: la zona de la imagen adaptada
   • PROJECT: tu Cloud de Confiance by S3NS ID del proyecto

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

Adapted image: IMAGE_NAME

¿Qué sigue?

Crea una instancia a partir de tu imagen.