AWS::CloudFormation::Init

Utilizza il tipo AWS::CloudFormation::Init per includere metadati in un'istanza Amazon EC2 per lo script helper cfn-init. Se il modello chiama lo script cfn-init, quest'ultimo cerca i metadati delle risorse radicati nella chiave di metadati AWS::CloudFormation::Init. Per ulteriori informazioni su cfn-init, consulta cfn-init.

cfn-init supporta tutti i tipi di metadati per i sistemi Linux. Supporta inoltre i tipi di metadati per Windows con le condizioni descritte nelle seguenti sezioni.

Per un esempio di utilizzo AWS::CloudFormation::Init dello script di supporto cfn-init per creare uno stack Linux, vedere. Distribuzione di applicazioni su Amazon EC2 con AWS CloudFormation Per un esempio di stack di Windows, vedi. Avvio degli stack di Windows AWS CloudFormation

Sintassi

La configurazione è divisa in sezioni. Il seguente frammento di modello mostra in che modo collegare i metadati per cfn-init a una risorsa istanza EC2 all'interno del modello.

I metadati vengono organizzati in chiavi di configurazione, raggruppabili in set di configurazione. Puoi specificare un set di configurazione quando chiami cfn-init nel modello. Se non specifichi un configset, cfn-init cerca una chiave di configurazione singola denominata config.

Nota

Lo script helper cfn-init elabora le sezioni di configurazione nell'ordine seguente: pacchetti, gruppi, utenti, origini, file, comandi e servizi. Se hai bisogno di seguire un ordine diverso, dividi le sezioni in chiavi di configurazione diverse, quindi utilizza un set di configurazione che specifichi l'ordine in cui le chiavi devono essere elaborate.

JSON

"Resources": {
  "MyInstance": {
    "Type": "AWS::EC2::Instance",
    "Metadata" : {
      "AWS::CloudFormation::Init" : {
        "config" : {
          "packages" : {
            :
          },
          "groups" : {
            :
          },
          "users" : {
            :
          },
          "sources" : {
            :
          },
          "files" : {
            :
          },
          "commands" : {
            :
          },
          "services" : {
            :
          }
        }
      }
    },
    "Properties": {
      :
    }
  }
}

YAML

Resources: 
  MyInstance: 
    Type: AWS::EC2::Instance
    Metadata: 
      AWS::CloudFormation::Init: 
        config: 
          packages: 
            :
          groups: 
            :
          users: 
            :
          sources: 
            :
          files: 
            :
          commands: 
            :
          services: 
            :
    Properties: 
      :

Nota

Le sezioni seguenti contengono esempi di script scritti in linguaggi di shell scripting simili a Unix, come Bash. Per creare PowerShell invece degli script, assicuratevi di conoscere bene il linguaggio. PowerShell PowerShell la sintassi è diversa dalle shell simili a Unix, quindi dovrai avere familiarità con il modo di fare le cose. PowerShell

Set di configurazione

Se desideri creare più chiavi di configurazione e impostarle in modo che cfn-init le elabori in un ordine specifico, crea un set di configurazione che contenga le chiavi nell'ordine desiderato.

Set di configurazione singolo

Il seguente frammento di modello crea set di configurazione denominati ascending e descending, ciascuno dei quali contenente due chiavi di configurazione.

JSON

"AWS::CloudFormation::Init" : {
    "configSets" : {
        "ascending" : [ "config1" , "config2" ],
        "descending" : [ "config2" , "config1" ]
    },
    "config1" : {
        "commands" : {
            "test" : {
                "command" : "echo \"$CFNTEST\" > test.txt",
                "env" : { "CFNTEST" : "I come from config1." },
                "cwd" : "~"
            }
        }
    },
    "config2" : {
        "commands" : {
            "test" : {
                "command" : "echo \"$CFNTEST\" > test.txt",
                "env" : { "CFNTEST" : "I come from config2" },
                "cwd" : "~"
            }
        }
    }
}     

YAML

AWS::CloudFormation::Init: 
  configSets: 
    ascending: 
      - "config1"
      - "config2"
    descending: 
      - "config2"
      - "config1"
  config1: 
    commands: 
      test: 
        command: "echo \"$CFNTEST\" > test.txt"
        env: 
          CFNTEST: "I come from config1."
        cwd: "~"
  config2: 
    commands: 
      test: 
        command: "echo \"$CFNTEST\" > test.txt"
        env: 
          CFNTEST: "I come from config2"
        cwd: "~"

Chiamate cfn-init correlate

Le seguenti chiamate di esempio a cfn-init fanno riferimento ai set di configurazione dell'esempio precedente. Le chiamate sono abbreviate per chiarezza. Per la sintassi completa, consulta cfn-init.

• Se una chiamata a cfn-init specifica il set di configurazione ascending:

  cfn-init -c ascending

  lo script elabora config1 e poi config2 e il file test.txt conterrà il testo I come from config2.

• Se una chiamata a cfn-init specifica il set di configurazione descending:

  cfn-init -c descending

  lo script elabora config2 e poi config1 e il file test.txt conterrà il testo I come from config1.

Più set di configurazione

Puoi creare più set di configurazione e chiamare una serie di set utilizzando lo script cfn-init. Ogni set di configurazione può contenere un elenco di chiavi di configurazione o di riferimenti ad altri set di configurazione. Ad esempio, il seguente frammento di modello crea tre set di configurazione. Il primo, test1, contiene una chiave di configurazione denominata 1. Il secondo, test2, contiene un riferimento al set di configurazione test1 e una chiave di configurazione denominata 2. Il terzo, default, contiene un riferimento al set di configurazione test2.

JSON

"AWS::CloudFormation::Init" : {
    "configSets" : {
        "test1" : [ "1" ],
        "test2" : [ { "ConfigSet" : "test1" }, "2" ],
        "default" : [ { "ConfigSet" : "test2" } ]
    },
    "1" : {
        "commands" : {
            "test" : {
                "command" : "echo \"$MAGIC\" > test.txt",
                "env" : { "MAGIC" : "I come from the environment!" },
                "cwd" : "~"
            }
        }
    },
    "2" : {
        "commands" : {
            "test" : {
                "command" : "echo \"$MAGIC\" >> test.txt",
                "env" : { "MAGIC" : "I am test 2!" },
                "cwd" : "~"
            }
        }
    }
}

YAML

AWS::CloudFormation::Init:
  1:
    commands:
      test:
        command: "echo \"$MAGIC\" > test.txt"
        env:
          MAGIC: "I come from the environment!"
        cwd: "~"
  2:
    commands:
      test:
        command: "echo \"$MAGIC\" >> test.txt"
        env:
          MAGIC: "I am test 2!"
        cwd: "~"
  configSets: 
    test1:
      - "1"
    test2:
      -
        ConfigSet: "test1"
      - "2"
    default:
      -
        ConfigSet: "test2"

Chiamate cfn-init correlate

Le seguenti chiamate a cfn-init fanno riferimento ai set di configurazione dichiarati nel frammento di modello precedente. Le chiamate sono abbreviate per chiarezza. Per la sintassi completa, consulta cfn-init.

• Se specifichi solo test1:

  cfn-init -c test1

  cfn-init elabora solo la chiave di configurazione 1.

• Se specifichi solo test2:

  cfn-init -c test2

  cfn-init elabora la chiave di configurazione 1 e poi la chiave di configurazione 2.

• Se specifichi il set di configurazione default (o non specifichi alcun set di configurazione):

  cfn-init -c default

  ottieni lo stesso comportamento che avresti specificando il set di configurazione test2.

Comandi

Puoi utilizzare la chiave comandi per eseguire comandi sull'istanza EC2. I comandi vengono elaborati in ordine alfabetico in base al nome.

Chiave	Richiesto	Descrizione
command	Richiesto	Una matrice o una stringa che specifica il comando da eseguire. Se utilizzi una matrice, non è necessario utilizzare un carattere di escape negli spazi o racchiudere i parametri di comando tra virgolette. Non utilizzare una matrice per specificare più comandi.
env	Facoltativo	Imposta variabili di ambiente per il comando. Questa proprietà non aggiunge l'ambiente esistente ma lo sovrascrive.
cwd	Facoltativo	La directory di lavoro.
test	Facoltativo	Un comando di test che determina se cfn-init esegue i comandi specificati nella chiave comandi. Se il test viene superato, cfn-init esegue i comandi. Lo script cfn-init esegue il test in un interprete di comandi, ad esempio Bash o cmd.exe. Il superamento del test dipende dal codice di uscita restituito dall'interprete. Per Linux, il comando di test deve restituire il codice di uscita 0 perché il test abbia esito positivo. Per Windows, il comando di test deve restituire un %ERRORLEVEL% di 0.
ignoreErrors	Facoltativo	Un valore booleano che determina se l'esecuzione di cfn-init continua se il comando contenuto nella chiave comandi non riesce (restituisce un valore diverso da zero). Imposta su true per continuare a eseguire cfn-init anche se il comando non riesce. Imposta su false per interrompere l'esecuzione di cfn-init se il comando non riesce. Il valore predefinito è false.
waitAfterCompletion	Facoltativo	Solo per i sistemi Windows. Specifica il tempo di attesa (in secondi) dopo che un comando è terminato nel caso in cui il comando provochi un riavvio. Il valore di default è di 60 secondi e il valore "forever" indica a cfn-init di uscire e riprendere solo dopo il completamento del processo di riavvio. Impostare questo valore su 0 se non si desidera attendere ogni comando.

Esempio

Il seguente frammento di esempio chiama il comando echo se il file ~/test.txt non esiste.

JSON

"commands" : {
    "test" : {
        "command" : "echo \"$MAGIC\" > test.txt",
        "env" : { "MAGIC" : "I come from the environment!" },
        "cwd" : "~",
        "test" : "test ! -e ~/test.txt",
        "ignoreErrors" : "false"
    },
    "test2" : {
        "command" : "echo \"$MAGIC2\" > test2.txt",
        "env" : { "MAGIC2" : "I come from the environment!" },
        "cwd" : "~",
        "test" : "test ! -e ~/test2.txt",
        "ignoreErrors" : "false"
    }
}

YAML

commands:
  test:
    command: "echo \"$MAGIC\" > test.txt"
    env:
      MAGIC: "I come from the environment!"
    cwd: "~"
    test: "test ! -e ~/test.txt"
    ignoreErrors: "false"
  test2:
    command: "echo \"$MAGIC2\" > test2.txt"
    env:
      MAGIC2: "I come from the environment!"
    cwd: "~"
    test: "test ! -e ~/test2.txt"
    ignoreErrors: "false"

File

Puoi utilizzare la chiave files per creare file sull'istanza EC2. Il contenuto può essere inline nel modello o essere estratto da un URL. I file sono scritti su disco in ordine lessicografico. La tabella seguente elenca le chiavi supportate.

Chiave	Descrizione
contenuto	Una stringa o un oggetto JSON formattato correttamente. Se utilizzi un oggetto JSON come contenuto, il codice JSON verrà scritto in un file su disco. Le funzioni intrinseche come Fn::GetAtt o Ref vengono valutate prima che l'oggetto JSON venga scritto sul disco. Quando crei un collegamento simbolico, specificane la destinazione come contenuto. Nota Se crei un collegamento simbolico, lo script helper modifica le autorizzazioni del file di destinazione. Al momento, non è possibile creare un collegamento simbolico senza modificare le autorizzazioni del file di destinazione.
source	Un URL da cui caricare il file. Questa opzione non può essere specificata con la chiave contenuto.
encoding	Il formato di codifica. Utilizzata solo se il contenuto è una stringa. La codifica non viene applicata se si sta utilizzando un'origine. Valori validi: plain | base64
gruppo	Il nome del gruppo proprietario di questo file. Questa chiave non è supportata per i sistemi Windows.
owner	Il nome dell'utente proprietario di questo file. Questa chiave non è supportata per i sistemi Windows.
mode	Valore ottale a sei cifre che rappresenta la modalità per questo file. Questa chiave non è supportata per i sistemi Windows. Usa le prime tre cifre per i collegamenti simbolici e le ultime tre per impostare le autorizzazioni. Per creare un collegamento simbolico, specifica 120xxx, dove xxx definisce le autorizzazioni del file di destinazione. Per specificare le autorizzazioni per un file, usa le ultime tre cifre, ad esempio 000644.
autenticazione	Il nome di un metodo di autenticazione da utilizzare. Questa proprietà sostituisce qualsiasi impostazione di autenticazione di default. Puoi utilizzarla per selezionare un metodo di autenticazione definito con la risorsa AWS::CloudFormation::Authentication.
context	Specifica un contesto per i file che devono essere elaborati come modelli Mustache. Per utilizzare questa chiave, è necessario aver installato aws-cfn-bootstrap 1.3–11 o versioni successive e pystache.

Esempi

Il seguente frammento di esempio crea un file denominato setup.mysql come parte di una installazione più ampia.

JSON

"files" : {
  "/tmp/setup.mysql" : {
    "content" : { "Fn::Join" : ["", [
      "CREATE DATABASE ", { "Ref" : "DBName" }, ";\n",
      "CREATE USER '", { "Ref" : "DBUsername" }, "'@'localhost' IDENTIFIED BY '",
                       { "Ref" : "DBPassword" }, "';\n",
      "GRANT ALL ON ", { "Ref" : "DBName" }, ".* TO '", { "Ref" : "DBUsername" },
                       "'@'localhost';\n",
      "FLUSH PRIVILEGES;\n"
      ]]},
    "mode"  : "000644",
    "owner" : "root",
    "group" : "root"
  }
}

YAML

files: 
  /tmp/setup.mysql: 
    content: !Sub |
      CREATE DATABASE ${DBName};
      CREATE USER '${DBUsername}'@'localhost' IDENTIFIED BY '${DBPassword}';
      GRANT ALL ON ${DBName}.* TO '${DBUsername}'@'localhost';
      FLUSH PRIVILEGES;
    mode: "000644"
    owner: "root"
    group: "root"

Il modello completo è disponibile all'indirizzo: https://s3.amazonaws.com/ -1/drupal_single_instance.template cloudformation-templates-us-east

Il seguente frammento di esempio crea il collegamento simbolico /tmp/myfile2.txt che punta al file esistente /tmp/myfile1.txt. Le autorizzazioni del file di destinazione /tmp/myfile1.txt sono definite dal valore di modalità 644.

JSON

"files" : {
  "/tmp/myfile2.txt" : {
    "content" : "/tmp/myfile1.txt",
    "mode" : "120644"
  }
}

YAML

files:
  /tmp/myfile2.txt:
    content: "/tmp/myfile1.txt"
    mode: "120644"

I modelli Mustache vengono utilizzati principalmente per creare file di configurazione. Ad esempio, puoi memorizzare un file di configurazione in un bucket S3 e interpolare Refs e dal modello, invece di usare. GetAtts Fn::Join Il seguente frammento di esempio restituisce come output "Content for test9" in /tmp/test9.txt.

JSON

"files" : {
    "/tmp/test9.txt" : {
        "content" : "Content for {{name}}",
        "context" : { "name" : "test9" }
    }
} 

YAML

files:
  /tmp/test9.txt:
    content: "Content for {{name}}"
    context:
      name: "test9"

Quando utilizzi i modelli Mustache, nota quanto segue:

• La chiave contesto deve essere presente per i file da elaborare.

• La chiave contesto deve essere una mappa chiave-valore, ma può essere annidata.

• È possibile elaborare file con contenuti inline utilizzando la chiave contenuti e i file remoti tramite la chiave origine.

• Il supporto Mustache dipende dalla versione di pystache. La versione 0.5.2 supporta la specifica Mustache 1.1.2.

Gruppi

Puoi utilizzare la chiave gruppi per creare gruppi Linux/UNIX e per assegnare ID gruppo. La chiave gruppi non è supportata per i sistemi Windows.

Per creare un gruppo, aggiungi una nuova coppia chiave-valore che esegue la mappatura di un nuovo nome di gruppo a un ID di gruppo facoltativo. La chiave "groups" può contenere uno o più nomi di gruppo. La tabella seguente elenca le chiavi disponibili.

Chiave	Descrizione
gid	Un numero di ID di gruppo. Se viene specificato un ID di gruppo e il nome di gruppo esiste già, la creazione del gruppo non riuscirà. Se un altro gruppo ha l'ID gruppo specificato, il sistema operativo può rifiutare la creazione del gruppo. Esempio: { "gid" : "23" }

Frammento di esempio

Il frammento seguente specifica un gruppo denominato groupOne senza assegnare un ID gruppo e un gruppo denominato groupTwo con il valore 45 come ID gruppo.

JSON

"groups" : {
    "groupOne" : {},
    "groupTwo" : { "gid" : "45" }
}

YAML

groups:
  groupOne: {}
  groupTwo:
    gid: "45"

Pacchetti

Puoi utilizzare la chiave pacchetti per scaricare e installare pacchetti di componenti e applicazioni. Nei sistemi Windows, questa chiave supporta solo il programma di installazione MSI.

Formati di pacchetto supportati

Lo script cfn-init attualmente supporta i seguenti formati di pacchetto: apt, msi, python, rpm, rubygems, yum e Zypper. I pacchetti vengono elaborati nel seguente ordine: rpm, yum/apt/zypper, quindi rubygems e python. Non esiste alcun ordine prestabilito tra rubygems e python e l'installazione dei pacchetti nei programmi di gestione dei pacchetti non segue un ordine definito.

Specificazione delle versioni

In ogni programma di gestione dei pacchetti, ogni pacchetto è specificato come nome di pacchetto ed elenco di versioni. La versione può essere una stringa, un elenco di versioni oppure una stringa o un elenco vuoto. Una stringa o un elenco vuoto indica che deve essere utilizzata la versione più recente. Per il programma rpm, la versione è specificata come percorso a un file su un disco o a un URL.

Se specifichi una versione di un pacchetto, cfn-init tenterà di installare tale versione anche se una versione più recente del pacchetto è già installata nell'istanza. Solo alcuni programmi di gestione dei pacchetti supportano più versioni. Per ulteriori informazioni, consulta la documentazione del programma di gestione dei pacchetti utilizzato. Se non si specifica una versione e una versione del pacchetto è già installata, lo script cfn-init non installerà una nuova versione perché presupporrà che intendi continuare a utilizzare la versione esistente.

Frammenti di esempio

RPM, yum, Rubygems e Zypper

Il frammento seguente specifica un URL di versione per rpm, richiede le versioni più recenti da yum e Zypper e la versione 0.10.2 di chef da rubygems:

JSON

"rpm" : {
  "epel" : "http://download.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm"
},
"yum" : {
  "httpd" : [],
  "php" : [],
  "wordpress" : []
},
"rubygems" : {
  "chef" : [ "0.10.2" ]
},
"zypper" : {
  "git" : []
}

YAML

rpm:
  epel: "http://download.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm"
yum:
  httpd: []
  php: []
  wordpress: []
rubygems:
  chef:
    - "0.10.2"
zypper:
  git: []

Pacchetto MSI

Il frammento seguente specifica un URL per un pacchetto MSI:

JSON

"msi" : {
  "awscli" : "https://s3.amazonaws.com/aws-cli/AWSCLI64.msi"
}

YAML

msi:
  awscli: "https://s3.amazonaws.com/aws-cli/AWSCLI64.msi"

Servizi

Puoi utilizzare la chiave servizi per definire i servizi che devono essere abilitati o disabilitati all'avvio dell'istanza. Sui sistemi Linux, questa chiave è supportata utilizzando sysvinit o systemd. Sui sistemi Windows, è supportata tramite l'utilizzo di Windows Service Manager.

La chiave servizi consente inoltre di specificare le dipendenze da origini, pacchetti e file, per cui, se è necessario un riavvio a seguito dell'installazione dei file, cfn-init si occupa del riavvio del servizio. Ad esempio, se scarichi il pacchetto Apache HTTP Server, l'installazione del pacchetto avvierà automaticamente Apache HTTP Server durante il processo di creazione dello stack. Tuttavia, se la configurazione di Apache HTTP Server viene successivamente aggiornata nel processo di creazione dello stack, l'aggiornamento non sarà effettivo se il server Apache non viene riavviato. È possibile utilizzare la chiave servizi per assicurare che il servizio Apache HTTP venga riavviato.

La tabella seguente elenca le chiavi supportate.

Chiave	Descrizione
ensureRunning	Imposta su true per continuare a eseguire il servizio dopo la chiusura di cfn-init. Impostare su false per interrompere l'esecuzione del servizio dopo la chiusura di cfn-init. Ometti la chiave per non apportare modifiche allo stato del servizio.
abilitato	Imposta su true per eseguire automaticamente il servizio all'avvio. Impostare su false per non eseguire automaticamente il servizio all'avvio. Ometti la chiave per non apportare modifiche a questa proprietà.
files	Un elenco di file. Se cfn-init ne modifica uno direttamente tramite il blocco di file, questo servizio viene riavviato.
sources	Un elenco di directory. Se cfn-init espande un archivio in una di queste directory, questo servizio viene riavviato.
packages	Una mappa del programma di gestione dei pacchetti con l'elenco dei nomi di pacchetto. Se cfn-init installa o aggiorna uno di questi pacchetti, questo servizio viene riavviato.
comandi	Un elenco di nomi di comando. Se cfn-init esegue il comando specificato, questo servizio viene riavviato.

Esempi

Linux

Il seguente frammento Linux configura i servizi come segue:

• Il servizio nginx verrà riavviato se /etc/nginx/nginx.conf o /var/www/html vengono modificati da cfn-init.

• Il servizio php-fastcgi verrà riavviato se cfn-init installa o aggiorna php o spawn-fcgi utilizzando yum.

• Il servizio sendmail verrà interrotto e disabilitato utilizzando systemd.

JSON

"services" : {
  "sysvinit" : {
    "nginx" : {
      "enabled" : "true",
      "ensureRunning" : "true",
      "files" : ["/etc/nginx/nginx.conf"],
      "sources" : ["/var/www/html"]
    },
    "php-fastcgi" : {
      "enabled" : "true",
      "ensureRunning" : "true",
      "packages" : { "yum" : ["php", "spawn-fcgi"] }
    }
  },
  "systemd": {
    "sendmail" : {
      "enabled" : "false",
      "ensureRunning" : "false"
    }
  }
}

YAML

services:
  sysvinit:
    nginx:
      enabled: "true"
      ensureRunning: "true"
      files:
        - "/etc/nginx/nginx.conf"
      sources:
        - "/var/www/html"
    php-fastcgi:
      enabled: "true"
      ensureRunning: "true"
      packages:
        yum:
          - "php"
          - "spawn-fcgi"
  systemd:
    sendmail:
      enabled: "false"
      ensureRunning: "false"

Per usare systemd con un servizio, il servizio deve avere un file di unità systemd configurato. Il seguente file di unità consente a systemd di avviare e arrestare il daemon cfn-hup nella destinazione del servizio multiutente:

[Unit]
Description=cfn-hup daemon
[Service]
ExecStart=/usr/bin/cfn-hup -v
PIDFile=/var/run/cfn-hup.pid
[Install]
WantedBy=multi-user.target

Questa configurazione presuppone che cfn-hup sia installato nella directory /usr/bin. Tuttavia, la posizione effettiva in cui è installato cfn-hup potrebbe variare su piattaforme diverse. Puoi ignorare questa configurazione creando un file di sostituzione in /etc/systemd/system/cfn-hup.service.d/override.conf come segue:

# In this example, cfn-hup executable is available under /usr/local/bin
[Service]
ExecStart=
ExecStart=/usr/local/bin/cfn-hup -v

Windows

Il seguente frammento Windows avvia il servizio cfn-hup, lo imposta sulla modalità automatica e lo riavvia se cfn-init modifica i file di configurazione specificati:

JSON

"services" : {
  "windows" : {
    "cfn-hup" : {
      "enabled" : "true",
      "ensureRunning" : "true",
      "files" : ["c:\\cfn\\cfn-hup.conf", "c:\\cfn\\hooks.d\\cfn-auto-reloader.conf"]
    }
  }
}

YAML

services:
  windows:
    cfn-hup:
      enabled: "true"
      ensureRunning: "true"
      files:
        - "c:\\cfn\\cfn-hup.conf"
        - "c:\\cfn\\hooks.d\\cfn-auto-reloader.conf"

Origini

È possibile utilizzare la chiave origini per scaricare un file di archivio e decomprimerlo in una directory di destinazione nell'istanza EC2. Questa chiave è completamente supportata sia sui sistemi Linux che sui sistemi Windows.

Formati supportati

I formati supportati sono:

• tar

• tar+gzip

• tar+bz2

• zip

Esempi

GitHub

Se si utilizza GitHub come sistema di controllo del codice sorgente, è possibile utilizzare cfn-init e il meccanismo del pacchetto sources per estrarre una versione specifica dell'applicazione. GitHub consente di creare un file.zip o un .tar da una versione specifica tramite un URL come segue:

https://github.com/<your directory>/(zipball|tarball)/<version>

Ad esempio, il frammento seguente estrae la versione main come file .tar.

JSON

"sources" : {
  "/etc/puppet" : "https://github.com/user1/cfn-demo/tarball/main"
  }

YAML

sources:
  /etc/puppet: "https://github.com/user1/cfn-demo/tarball/main"

Bucket S3

L'esempio seguente scarica un tarball da un bucket S3 e lo decomprime in /etc/myapp:

Nota

È possibile utilizzare le credenziali di autenticazione per un'origine. Tuttavia, non è possibile inserire un codice di autenticazione nel blocco sources. Al suo posto, includere una chiave dei bucket nel proprio blocco S3AccessCreds. Per ulteriori informazioni sulle credenziali di autenticazione Amazon S3, consulta AWS::CloudFormation::Authentication.

Per un esempio, consulta il modello di esempio.

JSON

"sources" : {
  "/etc/myapp" : "https://s3.amazonaws.com/mybucket/myapp.tar.gz"
  }

YAML

sources:
  /etc/myapp: "https://s3.amazonaws.com/mybucket/myapp.tar.gz"

Utenti

Puoi utilizzare la chiave utenti per creare utenti Linux/UNIX nell'istanza EC2. La chiave utenti non è supportata per i sistemi Windows.

La tabella seguente elenca le chiavi supportate.

Chiave	Descrizione
uid	Un ID utente. Il processo di creazione non riesce se esiste un nome utente con un ID utente differente. Se l'ID utente è già assegnato a un utente esistente, il sistema operativo può respingere la richiesta di creazione.
gruppi	Un elenco di nomi di gruppo. L'utente viene aggiunto a ogni gruppo nell'elenco.
homeDir	La home directory dell'utente.

Esempio

Gli utenti vengono creati come utenti di sistema non interattivo con una shell di /sbin/nologin. Questa è un'impostazione predefinita e non può essere modificata.

JSON

"users" : {
    "myUser" : {
        "groups" : ["groupOne", "groupTwo"],
        "uid" : "50",
        "homeDir" : "/tmp"
    }
}

YAML

users:
  myUser:
    groups:
      - "groupOne"
      - "groupTwo"
    uid: "50"
    homeDir: "/tmp"