Usa gli stati delle attività con l'imaging del server

L'estensione dello stato esteso del server OpenStack ha esposto alcuni stati di nuova attività che forniscono una visibilità più dettagliata dello stato del server durante il processo di creazione dell'immagine (o "istantanea"). Questo articolo descrive cosa sono e suggerisce come utilizzarli.

Prima del rilascio di OpenStack Grizzly, quando si richiedeva un'azione di creazione dell'immagine su un server, il server entrava in uno speciale stato attività di image_snapshot e rimarrebbe in questo stato di attività fino al completamento dell'immagine. Questo singolo stato di attività nascondeva il fatto che ci sono tre fasi distinte per un'operazione di snapshot:

1. L'hypervisor crea un'immagine del disco rigido virtuale del server.
2. L'hypervisor impacchetta l'immagine e la prepara per il caricamento nell'archivio immagini.
3. L'hypervisor carica l'immagine del pacchetto nell'archivio immagini.

Durante la fase 1, dovresti evitare qualsiasi operazione che modificherebbe i dati sul disco rigido virtuale del server. In caso contrario, lo snapshot registrato potrebbe includere incongruenze da cui alcuni programmi applicativi sul server, principalmente database, potrebbero non essere in grado di ripristinare quando si esegue l'avvio dall'immagine.

In entrambe le fasi 2 e 3, l'hypervisor lavora per conto del tuo server ma non fa nulla con il tuo disco rigido virtuale. Di gran lunga, la terza fase, in cui avviene il caricamento, richiede più tempo per essere completata.

La versione OpenStack Grizzly ha modificato leggermente la semantica dello stato image_snapshottask e ha aggiunto due nuovi stati delle attività. Quindi ora, il tuo server esegue i seguenti stati di attività durante l'elaborazione di un'azione di creazione dell'immagine:

1. image_snapshot:l'hypervisor crea un'immagine del disco rigido virtuale del server
2. image_pending_upload:l'hypervisor impacchetta l'immagine e la prepara per il caricamento
3. image_uploading:l'hypervisor carica l'immagine nell'imagestore

Sebbene il tuo server sia uno di questi stati di attività, non puoi eseguire un'altra azione di creazione dell'immagine su quel server. Come puoi vedere dalle descrizioni degli stati delle attività, l'hypervisor è coinvolto in tutte e tre le fasi dell'azione di creazione dell'immagine, quindi tutte le risorse contabili aggiuntive che l'hypervisor ha allocato al tuo server sono in uso. Devi attendere che l'intero processo di snapshot sia completato e rilasci queste risorse prima di poter creare un altro snapshot.

Dopo che la prima fase è stata completata, non devi più preoccuparti che le operazioni sul tuo server possano interferire con l'efficacia della tua istantanea. Sfortunatamente, il Pannello di controllo non espone gli stati delle attività del server. Tuttavia, puoi verificarli utilizzando l'API o python-novaclient .

Utilizza l'API per controllare lo stato delle attività del server

Gli stati dell'attività vengono visualizzati nella seguente risposta all'operazione dettagliata del server:

GET /v2/servers/{serverId}

Ecco una risposta dettagliata del server JSON abbreviata:

{
    "server": {
        "OS-EXT-STS:power_state": 1,
        "OS-EXT-STS:task_state": "image_pending_upload",
        "OS-EXT-STS:vm_state": "active",
        /* ... */
        "id": "c2d5da0a-80d7-4ca7-872c-505410ab55d0",
        /* ... */
        "name": "check-my-task-state",
        "progress": 100,
        "status": "ACTIVE",
   }
}

Cerca OS-EXT-STS:task_state elemento. Poiché un oggetto JSON non è ordinato, potrebbe apparire ovunque nella risposta. Dal valore visualizzato in questo esempio, puoi vedere che l'hypervisor ha terminato la creazione dell'immagine del disco rigido virtuale del server e ora sta impacchettando e preparando l'immagine per il caricamento.

Utilizza python-novaclient per controllare lo stato dell'attività del server

python-novaclient è un pratico programma che puoi eseguire dalla riga di comando. Se non l'hai mai usato prima, ecco alcuni How-Toarticles da controllare:

• Installazione di python-openstackclient su Linux e MacOS
• Installazione di python-novaclient su Windows

Questi articoli forniscono una panoramica di python-novaclient e completa le istruzioni per installarlo sul tuo sistema operativo.

Per visualizzare lo stato dell'attività per un server utilizzando python-novaclient , fai uno show operazione sul server:

$ nova show {serverId}

Ecco una risposta abbreviata:

+------------------------+---------------------------------------+
| Property               | Value                                 |
+------------------------+---------------------------------------+
| status                 | ACTIVE                                |
| OS-EXT-STS:task_state  | None                                  |
| OS-EXT-STS:vm_state    | active                                |
| id                     | 933e803f-13b0-4698-a5c7-f74ec424fd38  |
| name                   | check-my-task-state                   |
| OS-DCF:diskConfig      | MANUAL                                |
| progress               | 100                                   |
| OS-EXT-STS:power_state | 1                                     |
| metadata               | {}                                    |
+------------------------+---------------------------------------+

In questo esempio, puoi vedere che non esiste uno stato di attività per il server, quindi potrebbe accettare un image-create richiesta.

Sondaggio per verificare lo stato dell'attività del server

Potresti voler scoprire lo stato dell'attività del server corrente prima di eseguire una delle seguenti attività:

1. Interrompi le attività sul server che potrebbero influire sulla qualità dell'immagine del disco, come l'arresto di un sistema di gestione del database.
2. Emetti un server image-create comando utilizzando l'API, novaclient o il Pannello di controllo.
3. Controlla il server per vedere quando esce da image_snapshot stato dell'attività.
4. Riavvia le attività interrotte prima di acquisire l'istantanea, come ripristinare il sistema di gestione del database.

Puoi scrivere un semplice script Bash per monitorare il tuo server. Ecco un esempio della parte più rilevante, ma sentiti libero di ampliarlo. Leggi tutto e assicurati di sapere cosa sta facendo prima di usarlo. Utilizza quattro programmi (curl , egrep ,sed e date ) che sono installati per impostazione predefinita sulla maggior parte dei sistemi Linux®. Questo frammento è piuttosto primitivo, quindi devi usare control-C per fermare lo script.

# set these vars
#
# the API endpoint, e.g., "https://iad.servers.api.rackspacecloud.com/v2/123456"
API_ENDPOINT=
# your API username, e.g., "fredco"
API_USER=
# your API auth token, obtained from the Identity service
API_AUTH_TOKEN=
# the UUID of the server you want to monitor
API_SERVER=
# how long to pause in between requests, in seconds
SLEEP_TIME=30
# a temporary file, e.g., "/tmp/polling.json"
DETAIL_FIL=

# verify that the server exists
API_RESP_CODE=$(curl -X GET <br>
 -k -s <br>
 -H "X-Auth-User: $API_USER" <br>
 -H "X-Auth-Token: $API_AUTH_TOKEN" <br>
 -H "Accept: application/json" <br>
 -w "%{http_code}" <br>
 -o $DETAIL_FIL <br>
 "$API_ENDPOINT/servers/$API_SERVER")
if [ "$API_RESP_CODE" != "200" ] ; then
  echo "[error] can't find server $API_SERVER"
  exit 1
fi

while [ 0 ] ; do
   API_RESP_CODE=$(curl -s -k -X GET <br>
    -H "X-Auth-User: $API_USER" <br>
    -H "X-Auth-Token: $API_AUTH_TOKEN" <br>
    -H "Accept: application/json" <br>
    -w "%{http_code}" <br>
    -o $DETAIL_FIL <br>
  "$API_ENDPOINT/servers/$API_SERVER")
  if [ "$API_RESP_CODE" == "404" ] ; then
    echo "[info] server $API_SERVER has disappeared!"
    break
  fi
  RAW_STAT=$(egrep -o '"status": (".*?"|null)' $DETAIL_FIL | sed 's/"//g')
  VM_STAT=$(egrep -o '"OS-EXT-STS:vm_state": (".*?"|null)' $DETAIL_FIL | sed 's/OS-EXT-STS://;s/"//g')
  TASK_STAT=$(egrep -o '"OS-EXT-STS:task_state": (".*?"|null)' $DETAIL_FIL | sed 's/OS-EXT-STS://;s/"//g')
  POW_STAT=$(egrep -o '"OS-EXT-STS:power_state": (\d|null)' $DETAIL_FIL | sed 's/OS-EXT-STS://;s/"//g')
  TIME=$(date +"%H:%M:%S")
  echo "$TIME   $RAW_STAT   $VM_STAT   $TASK_STAT   $POW_STAT"
  sleep ${SLEEP_TIME:-45}
done

Se avvii uno script che contiene il frammento precedente e poi acquisisci un'istantanea del server, vedrai qualcosa di simile al seguente esempio:

17:14:41   status: ACTIVE   vm_state: active   task_state: null   power_state: 1
17:14:44   status: ACTIVE   vm_state: active   task_state: null   power_state: 1
17:14:48   status: ACTIVE   vm_state: active   task_state: image_snapshot   power_state: 1
17:14:51   status: ACTIVE   vm_state: active   task_state: image_pending_upload   power_state: 1
17:14:55   status: ACTIVE   vm_state: active   task_state: image_pending_upload   power_state: 1
17:14:58   status: ACTIVE   vm_state: active   task_state: image_pending_upload   power_state: 1
17:15:02   status: ACTIVE   vm_state: active   task_state: image_pending_upload   power_state: 1
17:15:05   status: ACTIVE   vm_state: active   task_state: image_uploading   power_state: 1
17:15:09   status: ACTIVE   vm_state: active   task_state: image_uploading   power_state: 1
    ...
17:16:19   status: ACTIVE   vm_state: active   task_state: image_uploading   power_state: 1
17:16:23   status: ACTIVE   vm_state: active   task_state: image_uploading   power_state: 1
17:16:26   status: ACTIVE   vm_state: active   task_state: null   power_state: 1
17:16:30   status: ACTIVE   vm_state: active   task_state: null   power_state: 1