Adapta los sistemas operativos para Trusted Cloud by S3NS

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

Trusted Cloud 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, 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 Trusted Cloud by S3NS 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 Trusted Cloud by S3NS.

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 es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las APIs de Trusted Cloud by S3NS . 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 y, luego, accede a gcloud CLI con tu identidad federada. Después de acceder, inicializa Google Cloud CLI ejecutando el siguiente comando: 

      gcloud init
    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 proporcionas a gcloud CLI.

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

      gcloud init

    Si deseas obtener más información, consulta Autentica para usar REST en la Trusted Cloud documentación de autenticación.

Secuencia de comandos de adaptación del SO

Para ayudarte a adaptar imágenes para Trusted Cloud by S3NS, Trusted Cloud 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 necesarios para que la imagen de SO funcione en Trusted Cloud 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 Trusted Cloud by S3NS.
  4. 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 Trusted Cloud by S3NS:

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.s3nsapis.fr/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 Trusted Cloud by S3NS, haz lo siguiente:

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

  3. 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 Trusted Cloud by S3NS
    • 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.