Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Introduzione ai libri di ricette **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Uno stack OpsWorks Stacks a livello di produzione richiede in genere alcune [personalizzazioni](customizing.md), il che spesso significa implementare un ricettario Chef personalizzato con una o più ricette, file di attributi o file modello. Questo argomento è un tutorial introduttivo all'implementazione di libri di cucina per Stacks. OpsWorks Per ulteriori informazioni su come OpsWorks Stacks utilizza i libri di cucina, che include una breve introduzione generale ai libri di cucina, consulta. [Libri di ricette e ricette](workingcookbook.md) Per ulteriori informazioni su come implementare e testare ricette Chef, consulta la pagina relativa all'[infrastruttura basata sui test con Chef, seconda edizione](https://www.amazon.com/Test-Driven-Infrastructure-Chef-Behavior-Driven-Development/dp/1449372201/ref=sr_1_fkmr0_1?ie=UTF8&qid=1405556803&sr=8-1-fkmr0&keywords=Test-Driven+Infrastructure+with+Chef%2C+2nd+Edition). Gli esempi del tutorial sono suddivisi in due sezioni: + [Nozioni di base sui libri di ricette](cookbooks-101-basics.md) è un set di procedure guidate di esempio destinate agli utenti che non hanno familiarità con Chef. Gli utenti esperti di Chef possono ignorare questa sezione. Gli esempi presentano le nozioni di base su come implementare libri di ricette per eseguire attività comuni, tra cui l'installazione di pacchetti o la creazione di directory. Per semplificare il processo, potrai utilizzare un paio di utili strumenti, [Vagrant](http://docs.vagrantup.com/v2/) e [Test Kitchen](http://kitchen.ci/), per eseguire la maggior parte degli esempi in locale in una macchina virtuale. Prima di iniziare [Nozioni di base sui libri di ricette](cookbooks-101-basics.md), consulta [Vagrant e Test Kitchen](#cookbooks-101-tools) per scoprire come installare e utilizzare questi strumenti. Poiché Test Kitchen non supporta ancora Windows, gli esempi sono tutti destinati a Linux, con note che indicano come adattarli a Windows. + [Implementazione di Cookbooks for Stacks OpsWorks](cookbooks-101-opsworks.md)descrive come implementare le ricette per OpsWorks Stacks, anche per gli stack di Windows. Include anche alcuni suggerimenti più avanzati, come usare Berkshelf per gestire libri di cucina esterni. Gli esempi sono stati scritti per i nuovi utenti di Chef, proprio come gli esempi contenuti in [Nozioni di base sui libri di ricette](cookbooks-101-basics.md). Tuttavia OpsWorks Stacks funziona in modo leggermente diverso rispetto al server Chef, quindi consigliamo agli utenti esperti di Chef di leggere almeno questa sezione. ## Vagrant e Test Kitchen Se utilizzi ricette per istanze Linux, Vagrant e Test Kitchen sono strumenti molto utili per la formazione e per lo sviluppo e i test iniziali. Questo fornisce brevi descrizioni di Vagrant e Test Kitchen e ti indirizza alle istruzioni di installazione e alle procedure dettagliate che ti consentiranno di configurare e familiarizzare con le basi su come utilizzare gli strumenti. Poiché Vagrant supporta Windows, ma Test Kitchen no, vengono forniti solo esempi Linux per questi strumenti. ### Vagrant [Vagrant](http://docs.vagrantup.com/v2/) offre un ambiente uniforme per eseguire e testare codice in una macchina virtuale. Supporta un'ampia varietà di ambienti, chiamati Vagrant box, ognuno dei quali rappresenta un sistema operativo configurato. Per OpsWorks Stacks, gli ambienti di interesse si basano su distribuzioni Ubuntu, Amazon o Red Hat Enterprise Linux (RHEL), quindi gli esempi utilizzano principalmente una casella Vagrant denominata. `opscode-ubuntu-12.04` Poiché Vagrant è disponibile per sistemi Linux, Windows e Macintosh, puoi utilizzare la workstation che preferisci per implementare e testare ricette in qualsiasi sistema operativo supportato. Gli esempi di questo capitolo sono stati creati su un sistema Ubuntu Linux, ma la traduzione delle procedure in sistemi Windows o Macintosh è semplice. Vagrant è fondamentalmente un wrapper per un provider di virtualizzazione. La maggior parte degli esempi utilizza il provider. [VirtualBox](https://www.virtualbox.org/) VirtualBox è gratuito e disponibile per i sistemi Linux, Windows e Macintosh. La procedura dettagliata di Vagrant fornisce istruzioni di installazione se non le hai già sul tuo sistema. VirtualBox Tieni presente che puoi eseguire ambienti basati su Ubuntu, VirtualBox ma Amazon Linux è disponibile solo per le istanze Amazon. EC2 Tuttavia, è possibile eseguire un sistema operativo simile come CentOS on VirtualBox, utile per lo sviluppo e il test iniziali. Per informazioni su altri provider, consulta la documentazione di [Vagrant](http://docs.vagrantup.com/v2/). In particolare, il fornitore di `vagrant-aws` plug-in consente di utilizzare Vagrant con istanze Amazon EC2 . Questo provider è particolarmente utile per testare ricette su Amazon Linux, disponibile solo su EC2 istanze Amazon. Il provider `vagrant-aws` è gratuito, ma devi avere un account AWS e pagare per tutte le risorse AWS che utilizzi. A questo punto, segui la [procedura dettagliata introduttiva](http://docs.vagrantup.com/v2/getting-started/index.html) di Vagrant, che descrive come installare Vagrant nella workstation e fornisce le nozioni di base su come utilizzare Vagrant. Tieni presente che gli esempi forniti in questo capitolo non utilizzano un repository Git e quindi puoi omettere questa parte della procedura guidata se lo desideri. ### Test Kitchen [Test Kitchen](http://kitchen.ci/) semplifica il processo di esecuzione e test dei libri di ricette in Vagrant. In pratica, quasi mai dovrai utilizzare Vagrant direttamente. Test Kitchen esegue la maggior parte delle attività comuni, tra cui: + Avvio di un'istanza in Vagrant. + Trasferimento di libri di ricette all'istanza. + Esecuzione delle ricette del libro di ricette nell'istanza. + Test delle ricette di un libro di ricette nell'istanza. + Utilizzo di SSH per accedere all'istanza. Invece di installare il pacchetto gem Test Kitchen direttamente, ti consigliamo di installare [Chef DK](https://www.chef.io/downloads). Oltre allo stesso Chef, questo pacchetto include Test Kitchen, [Berkshelf](http://berkshelf.com/) e molti altri strumenti utili. [ChefSpec](https://docs.chef.io/chefspec.html) A questo punto, ti consigliamo di seguire la [procedura guidata introduttiva](http://kitchen.ci/) di Test Kitchen, che fornisce le nozioni di base su come utilizzare Test Kitchen per eseguire e testare ricette. **Nota** Gli esempi inclusi in questo capitolo utilizzano Test Kitchen come pratico metodo di esecuzione di ricette. Se preferisci, puoi interrompere la procedura dettagliata introduttiva dopo aver completato la sezione relativa alla verifica manuale, che descrive tutto quello che devi sapere per gli esempi. Tuttavia, Test Kitchen è prevalentemente una piattaforma di test che supporta framework di test come [Bash Automated Test System (BATS)](https://github.com/sstephenson/bats). A un certo punto, dovrai completare la parte restante della procedura guidata per scoprire come utilizzare Test Kitchen per testare le ricette. # Nozioni di base sui libri di ricette **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). I libri di ricette sono perfetti per eseguire un'ampia gamma di attività. Gli argomenti seguenti presuppongono che tu non abbia mai utilizzato Chef e descrivono come usare i libri di ricette per eseguire alcune operazioni comuni. Poiché Test Kitchen non supporta ancora Windows, gli esempi sono tutti destinati a Linux, con note che indicano come adattarli a Windows. Se non hai mai utilizzato Chef, ti consigliamo di seguire questi esempi anche se lavori con Windows. La maggior parte degli esempi inclusi in questo argomento può essere utilizzata su istanze Windows con alcune lievi modifiche (annotate negli esempi). Tutti gli esempi vengono eseguiti su una macchina virtuale, perciò non è necessario disporre di un computer Linux. Ti basta installare Vagrant e Test Kitchen sulla tua normale workstation. **Nota** Se vuoi eseguire queste ricette su un'istanza di Windows, l'approccio più semplice è creare uno stack Windows ed eseguire le ricette su una delle istanze dello stack. Per ulteriori informazioni su come eseguire ricette su un'istanza OpsWorks Stacks Windows, consulta. [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md) Prima di continuare, assicurati di aver installato Vagrant e Test Kitchen e di aver completato le rispettive procedure guidate sulle nozioni di base. Per ulteriori informazioni, consulta [Vagrant e Test Kitchen](cookbooks-101.md#cookbooks-101-tools). **Topics** + [Struttura di una ricetta](cookbooks-101-basics-structure.md) + [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md) + [Esempio 2: gestione degli utenti](cookbooks-101-basics-users.md) + [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md) + [Esempio 4: aggiunta del controllo del flusso](cookbooks-101-basics-ruby.md) + [Esempio 5: utilizzo di attributi](cookbooks-101-basics-attributes.md) + [Esempio 6: creazione di file](cookbooks-101-basics-files.md) + [Esempio 7: esecuzione di comandi e script](cookbooks-101-basics-commands.md) + [Esempio 8: gestione dei servizi](cookbooks-101-basics-services.md) + [Esempio 9: utilizzo di Amazon EC2 Instances](cookbooks-101-basics-ec2.md) + [Fasi successive](cookbooks-101-basics-next.md) # Struttura di una ricetta **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Un libro di ricette è principalmente un set di *ricette*, in grado di eseguire un'ampia gamma di attività su un'istanza. Per chiarire come funziona l'implementazione delle ricette, è utile guardare un semplice esempio. Di seguito è riportata la ricetta per il livello [HAProxy](layers-haproxy.md) integrato. In questa fase soffermati solo sulla struttura generale, senza preoccuparti troppo dei dettagli, che saranno descritti nei successivi esempi. ``` package 'haproxy' do action :install end if platform?('debian','ubuntu') template '/etc/default/haproxy' do source 'haproxy-default.erb' owner 'root' group 'root' mode 0644 end end include_recipe 'haproxy::service' service 'haproxy' do action [:enable, :start] end template '/etc/haproxy/haproxy.cfg' do source 'haproxy.cfg.erb' owner 'root' group 'root' mode 0644 notifies :restart, "service[haproxy]" end ``` **Nota** Per questo e altri esempi di utilizzo di ricette di lavoro e file correlati, consulta le [ricette integrate di OpsWorks Stacks](https://github.com/aws/opsworks-cookbooks). L'esempio evidenzia gli elementi chiave della ricetta, che sono descritti nelle seguenti sezioni. **Topics** + [Resources](#cookbooks-101-basics-structure-resources) + [Controllo di flusso](#cookbooks-101-basics-structure-ruby) + [Ricette incluse](#cookbooks-101-basics-structure-include) ## Resources Le Ricette consistono in gran parte in un set di *risorse* Chef. Ognuna di esse specifica un particolare aspetto dello stato finale dell'istanza, ad esempio un pacchetto da installare o un servizio da avviare. L'esempio presenta quattro risorse: + Una `package` risorsa, che rappresenta un pacchetto installato, un [HAProxy server](http://haproxy.1wt.eu/) per questo esempio. + Una `service` risorsa, che rappresenta un servizio, il HAProxy servizio di questo esempio. + Due `template` risorse, che rappresentano file che devono essere creati da un modello specificato, due file di HAProxy configurazione per questo esempio. Le risorse forniscono un modo dichiarativo per specificare l'istanza. In background, a ogni risorsa è associato un *provider* che esegue le attività necessarie, ad esempio l'installazione di pacchetti, la creazione e la configurazione di directory, l'avvio di servizi e così via. Se i dettagli dell'attività dipendono dallo specifico sistema operativo, la risorsa ha più provider e usa il tipo appropriato per il sistema. Ad esempio, su un sistema Red Hat Linux, il provider `package` utilizza `yum` per l'installazione di pacchetti. In un sistema Ubuntu Linux, il provider `package` utilizza `apt-get`. Una risorsa come un blocco di codice Ruby viene implementata con il seguente formato generale. ``` resource_type "resource_name" do attribute1 'value1' attribute2 'value2' ... action :action_name notifies : action 'resource' end ``` Gli elementi sono: **Tipo di risorsa** (Obbligatorio) L'esempio include tre tipi di risorse: `package`, `service` e `template`. **Nome risorsa** (Obbligatorio) Il nome identifica la particolare risorsa e talvolta viene usato come valore di default per uno degli attributi. Nell'esempio, `package` rappresenta una risorsa di pacchetto denominata `haproxy` e la prima risorsa `template` rappresenta un file di configurazione denominato `/etc/default/haproxy`. **Attributes** (Facoltativo) Gli attributi specificano la configurazione delle risorse e variano in base al tipo di risorsa e alla sua configurazione. + Le risorse `template` dell'esempio definiscono esplicitamente una serie di attributi che specifica l'origine del file creato nonché il proprietario, il gruppo e la modalità. + Le risorse `package` e `service` esempio non definiscono in modo esplicito alcun attributo. Il nome della risorsa in genere è il valore di default per un attributo obbligatorio ed è talvolta tutto ciò che è necessario. Ad esempio, il nome della risorsa è il valore di default per l'attributo `package` della risorsa `package_name`, che è l'unico attributo obbligatorio. Ci sono anche alcuni attributi specializzati, denominati attributi di protezione, che specificano quando il provider di risorse deve eseguire un'azione. Ad esempio, l'attributo `only_if` indica al provider di risorse di eseguire un'azione solo se viene soddisfatta una condizione specificata. La HAProxy ricetta non utilizza gli attributi guard, ma vengono utilizzati in molti dei seguenti esempi. **Operazioni e notifiche** (Facoltativo) Azioni e notifiche specificano quali attività deve eseguire il provider. + `action` indica al provider di eseguire un'operazione specifica, ad esempio un'installazione o una creazione. Ogni risorsa dispone di un set di operazioni che dipendono da quella particolare risorsa, una delle quali è l'operazione predefinita. Nell'esempio, l'operazione della risorsa `package` è `install`, che indica al provider di installare il pacchetto. La prima risorsa `template` non include alcun elemento `action`, perciò il provider esegue l'operazione predefinita `create`. + `notifies` indica un altro provider della risorsa di eseguire un'operazione, ma solo se lo stato della risorsa è stato modificato. `notifies` viene in genere utilizzato con risorse quali `template` e `file` per eseguire attività come il riavvio di un servizio dopo la modifica di un file di configurazione. Le risorse non prevedono notifiche di default. Per le notifica, la risorsa deve avere un elemento `notifies` esplicito. Nella HAProxy ricetta, la seconda `template` risorsa notifica alla risorsa haproxy `service` di riavviare il HAProxy servizio se il file di configurazione associato è cambiato. Le risorse talvolta dipendono dal sistema operativo. + Alcune risorse possono essere utilizzate solo su sistemi Linux o Windows. Ad esempio, [package](https://docs.chef.io/chef/resources.html#package) installa pacchetti sui sistemi Linux e [windows\$1package](https://docs.chef.io/chef/resources.html#windows-package) installa pacchetti sui sistemi Windows. + Alcune risorse possono essere utilizzate con qualsiasi sistema operativo, ma dispongono di attributi specifici per un determinato sistema. Ad esempio, la risorsa [file](https://docs.chef.io/chef/resources.html#file) può essere utilizzata sia su sistemi Linux che Windows, ma dispone di set di attributi separati per la configurazione delle autorizzazioni. Per le descrizioni delle risorse standard, inclusi gli attributi, le operazioni e le notifiche disponibili per ciascuna risorsa, consulta la pagina relativa alle [informazioni su risorse e provider](https://docs.chef.io/resource.html). ## Controllo di flusso Poiché le ricette sono applicazioni Ruby, è possibile utilizzare le strutture di controllo di Ruby per integrare il controllo del flusso in una ricetta. Ad esempio, è possibile usare logica condizionale di Ruby per far sì che la ricetta si comporti in modo diverso su sistemi differenti. La HAProxy ricetta include un `if` blocco che utilizza una `template` risorsa per creare un file di configurazione, ma solo se la ricetta è in esecuzione su un sistema Debian o Ubuntu. È comune anche lo scenario che prevede l'uso di un loop per eseguire una risorsa più volte con diverse impostazioni di attributo. Ad esempio, è possibile creare un set di directory utilizzando un loop per eseguire una risorsa `directory` più volte con diversi nomi di directory. **Nota** Se non hai familiarità con Ruby, consulta l'articolo sulle [nozioni di base su Ruby per Chef](https://docs.chef.io/just_enough_ruby_for_chef.html), che illustra le informazioni necessarie per la maggior parte delle ricette. ## Ricette incluse `include_recipe` include altre ricette nel codice per permetterti di suddividere in moduli le ricette e riutilizzare lo stesso codice in più ricette. Quando esegui la ricetta host, Chef sostituisce ciascun elemento `include_recipe` con il codice della ricetta specificato prima di eseguire la ricetta host. Puoi identificare una ricetta inclusa utilizzando la sintassi standard `cookbook_name::recipe_name` di Chef, dove `recipe_name` omette l'estensione `.rb`. L'esempio include una ricetta`haproxy::service`, che rappresenta il HAProxy servizio. **Nota** Se utilizzi `include_recipe` in ricette in esecuzione su Chef 11.10 e versioni successive per includere una ricetta da un altro libro di ricette, devi utilizzare un'istruzione `depends` per dichiarare la dipendenza nel file `metadata.rb` del libro di ricette. Per ulteriori informazioni, consulta [Implementazione delle ricette: Chef 11.10](workingcookbook-chef11-10.md). # Esempio 1: installazione di pacchetti **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). L'installazione di un pacchetto è uno dei casi d'uso più comuni per le ricette e può essere molto semplice, a seconda del pacchetto. Ad esempio, la seguente ricetta installa Git su un sistema Linux. ``` package 'git' do action :install end ``` La [risorsa `package`](https://docs.chef.io/chef/resources.html#package) gestisce l'installazione di pacchetti. Per questo esempio, non è necessario specificare attributi. Il nome della risorsa è il valore di default per l'attributo `package_name` che identifica il pacchetto. L'operazione `install` indica al provider di installare il pacchetto. È possibile rendere il codice ancora più semplice saltando `install`; è l'operazione predefinita della risorsa `package`. Quando esegui la ricetta, Chef usa il provider appropriato per installare il pacchetto. Nel sistema Ubuntu che utilizzerai per l'esempio, il provider installa Git chiamando `apt-get`. **Nota** L'installazione di software su un sistema Windows richiede una procedura diversa. Per ulteriori informazioni, consulta [Installazione di software Windows](cookbooks-101-opsworks-install-software.md). Per utilizzare Test Kitchen per eseguire questa ricetta in Vagrant, devi prima impostare un libro di ricette e inizializzare e configurare Test Kitchen. Quanto segue è relativo a un sistema Linux, ma la procedura è essenzialmente simile per i sistemi Windows e Macintosh. Inizia aprendo una finestra del terminale, perché tutti gli esempi in questo capitolo utilizzano strumenti a riga di comando. **Per preparare il libro di ricette** 1. Nella directory principale, creare una sottodirectory denominata `opsworks_cookbooks`, che conterrà tutti i libri di ricette per questo capitolo. Creare quindi una sottodirectory per questo libro di ricette denominata `installpkg` e accedervi. 1. In `installpkg`, creare un file denominato `metadata.rb` che contiene il codice seguente. ``` name "installpkg" version "0.1.0" ``` Per semplicità, gli esempi in questo capitolo specificano solo il nome e la versione del libro di ricette, ma `metadata.rb` può contenere un'ampia gamma di metadati del libro di ricette. Per ulteriori informazioni, consulta l'articolo sulle [informazioni sui metadati dei libri di ricette](http://docs.chef.io/cookbook_repo.html#about-cookbook-metadata). **Nota** Assicurati di creare `metadata.rb` prima di inizializzare Test Kitchen, perché utilizza i dati per creare il file di configurazione di default. 1. In `installpkg`, eseguire `kitchen init`, che inizializza Test Kitchen e installa il driver Vagrant di default. 1. Il comando `kitchen init` crea un file di configurazione YAML in `installpkg` denominato `.kitchen.yml`. Aprire il file nell'editor di testo preferito. Il file `.kitchen.yml` include una sezione `platforms` che specifica su quali sistemi eseguire le ricette. Test Kitchen crea un'istanza ed esegue le ricette specificate su ciascuna piattaforma. **Nota** Per impostazione predefinita, Test Kitchen esegue le ricette una piattaforma alla volta. Aggiungendo un argomento `-p` a qualsiasi comando che crea un'istanza, Test Kitchen eseguirà le ricette su ogni piattaforma, in parallelo. Una singola piattaforma è sufficiente per questo esempio, quindi modificare `.kitchen.yml` per rimuovere la piattaforma `centos-6.4`. Il file `.kitchen.yml` dovrebbe ora apparire così: ``` --- driver: name: vagrant provisioner: name: chef_solo platforms: - name: ubuntu-12.04 suites: - name: default run_list: - recipe[installpkg::default] attributes: ``` Test Kitchen esegue solo le ricette incluse nell'elenco di esecuzione `.kitchen.yml`. Puoi identificare le ricette utilizzando il `[cookbook_name::recipe_name]` formato, dove *recipe\$1name* omette l'estensione. `.rb` Inizialmente, l'elenco di esecuzione `.kitchen.yml` contiene la ricetta predefinita del libro di ricette, `installpkg::default`. Questa è la ricetta da implementare, perciò non è necessario modificare l'elenco di esecuzione. 1. Crea una sottodirectory di `installpkg` denominata `recipes`. Se un libro di cucina contiene ricette, la maggior parte di esse, devono trovarsi nella sottodirectory. `recipes` È ora possibile aggiungere la ricetta al libro di ricette e utilizzare Test Kitchen per eseguirla su un'istanza. **Per eseguire la ricetta** 1. Creare un file denominato `default.rb` che contenga il codice di esempio dell'installazione Git tratto dall'inizio della sezione e salvarlo nella sottodirectory `recipes`. 1. Nella directory `installpkg`, eseguire `kitchen converge`. Questo comando avvia una nuova istanza di Ubuntu in Vagrant, copia i tuoi libri di cucina nell'istanza e avvia un'esecuzione di Chef per eseguire le ricette nell'elenco di esecuzione. `.kitchen.yml` 1. Per verificare che la ricetta sia riuscita, eseguire `kitchen login`, che apre una connessione SSH all'istanza. Quindi eseguire `git --version` per verificare la corretta installazione di Git. Per tornare alla workstation, eseguire `exit`. 1. Al termine dell'operazione, eseguire `kitchen destroy` per chiudere l'istanza. L'esempio successivo utilizza un altro libro di ricette. Questo esempio è un buon inizio, ma è molto semplice. L'installazione di altri pacchetti può risultare più complicata e richiedere l'esecuzione di una o più delle seguenti operazioni: + Creare e configurare un utente. + Creare una o più directory per dati, log e così via. + Installare uno o più file di configurazione. + Specificare nomi del pacchetto o valori degli attributi diversi per differenti sistemi operativi. + Avviare un servizio e quindi riavviarlo in base alle esigenze. Gli esempi seguenti descrivono come agire in questi casi e alcune altre utili operazioni. # Esempio 2: gestione degli utenti **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disabilitato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Un'altra semplice attività è la gestione degli utenti su un'istanza. La seguente ricetta aggiunge un nuovo utente a un'istanza di Linux. ``` user "myuser" do home "/home/newuser" shell "/bin/bash" end ``` È possibile utilizzare una risorsa [utente](https://docs.chef.io/chef/resources.html#user) per gestire gli utenti sia su sistemi Linux che Windows, anche se alcuni attributi si applicano a un solo sistema. L'esempio crea un utente denominato `myuser` e specifica directory principale e shell personali. Non vi sono operazioni specificate, perciò la risorsa utilizza l'operazione di default `create`. È possibile aggiungere attributi a `user` per specificare una serie di altre impostazioni, ad esempio la password o l'ID gruppo. È inoltre possibile utilizzare `user` per operazioni correlate alle gestione degli utenti, ad esempio per modificare le impostazioni utente o eliminare gli utenti. Per ulteriori informazioni, consulta la sezione relativa alla risorsa [user](https://docs.chef.io/chef/resources.html#user). **Per eseguire la ricetta** 1. Creare una directory in `opsworks_cookbooks` denominata `newuser` e accedervi. 1. Creare un file `metadata.rb` che contiene il codice seguente e salvarlo in `newuser`. ``` name "newuser" version "0.1.0" ``` 1. Inizializzare e configurare Test Kitchen come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md), quindi aggiungere una directory `recipes` all'interno della directory `newuser`. 1. Aggiungere il file `default.rb` con la ricetta di esempio alla directory `recipes` del libro di ricette. 1. Eseguire `kitchen converge` per eseguire la ricetta. 1. Usare `kitchen login` per accedere all'istanza e verificare l'esistenza del nuovo utente eseguendo `cat /etc/passwd`. L'utente `myuser` deve trovarsi in fondo al file. # Esempio 3: creazione di directory **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Quando installi un pacchetto su un'istanza, spesso devi creare alcuni file di configurazione e inserirli nella directory appropriata. Tuttavia, tali directory potrebbero non esistere ancora. È inoltre possibile che sia necessario creare directory per dati, file di log e così via. Ad esempio, per prima cosa avvii il sistema Ubuntu che usi per la maggior parte degli esempi, la `/srv` directory non ha sottodirectory. Se stai installando un server delle applicazioni, è probabile che tu voglia una directory `/srv/www/` e forse alcune sottodirectory per file di dati, log e così via. La ricetta seguente crea `/srv/www/` su un'istanza. ``` directory "/srv/www/" do mode 0755 owner 'root' group 'root' action :create end ``` Una [risorsa `directory`](https://docs.chef.io/chef/resources.html#directory) serve a creare e configurare directory su sistemi Linux e Windows, anche se alcuni attributi vengono utilizzati in modo diverso. Il nome della risorsa è il valore di default per l'attributo `path` della risorsa, perciò l'esempio crea `/srv/www/` e ne specifica le proprietà `mode`, `owner` e `group`. **Per eseguire la ricetta** 1. Creare una directory in `opsworks_cookbooks` denominata `createdir` e aprirla. 1. Inizializzare e configurare Test Kitchen come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md), quindi aggiungere una directory `recipes` all'interno di `createdir`. 1. Aggiungere un file `default.rb` con il codice della ricetta alla sottodirectory `recipes` del libro di ricette. 1. Eseguire `kitchen converge` per eseguire la ricetta. 1. Eseguire `kitchen login`, individuare `/srv` e verificare che includa una sottodirectory `www`. 1. Eseguire `exit` per tornare alla workstation, ma lasciare l'istanza in esecuzione. **Nota** Per creare una directory relativa alla directory principale dell'istanza, utilizzare `#{ENV['HOME']}` per rappresentare la directory principale. Ad esempio, quanto segue crea la directory `~/shared`. ``` directory "#{ENV['HOME']}/shared" do ... end ``` Supponiamo di voler creare una directory nidificata più profondamente, ad esempio `/srv/www/shared`. È possibile modificare la ricetta precedente come segue. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' action :create end ``` **Per eseguire la ricetta** 1. Sostituire il codice in `default.rb` con la ricetta precedente. 1. Eseguire `kitchen converge` nella directory `createdir`. 1. Per verificare che la directory sia stata effettivamente creata, eseguire `kitchen login`, individuare `/srv/www` e verificare che contenga una sottodirectory `shared`. 1. Eseguire `kitchen destroy` per arrestare l'istanza. Noterai che il comando `kitchen converge` è stato eseguito molto più velocemente. Questo perché l'istanza è già in esecuzione, quindi non è necessario avviare l'istanza, installare Chef e così via. Test Kitchen si limita a copiare il libro di ricette aggiornato nell'istanza e avvia un'esecuzione Chef. Ora esegui nuovamente `kitchen converge`, che esegue la ricetta su una nuova istanza. Verrà visualizzato un risultato analogo al seguente. ``` Chef Client failed. 0 resources updated in 1.908125788 seconds [2014-06-20T20:54:26+00:00] ERROR: directory[/srv/www/shared] (createdir::default line 1) had an error: Chef::Exceptions::EnclosingDirectoryDoesNotExist: Parent directory /srv/www does not exist, cannot create /srv/www/shared [2014-06-20T20:54:26+00:00] FATAL: Chef::Exceptions::ChildConvergeError: Chef run process exited unsuccessfully (exit code 1) >>>>>> Converge failed on instance . >>>>>> Please see .kitchen/logs/default-ubuntu-1204.log for more details >>>>>> ------Exception------- >>>>>> Class: Kitchen::ActionFailed >>>>>> Message: SSH exited (1) for command: [sudo -E chef-solo --config /tmp/kitchen/solo.rb --json-attributes /tmp/kitchen/dna.json --log_level info] >>>>>> ---------------------- ``` Che cos'è successo? Il problema è che, per impostazione predefinita, una risorsa `directory` può creare una sola directory alla volta, non una serie di directory. La ricetta ha funzionato in precedenza perché la prima ricetta eseguita sull'istanza aveva già creato `/srv/www`, perciò con la creazione di `/srv/www/shared` è stata creata una sola sottodirectory. **Nota** Quando esegui `kitchen converge`, verifica se stai eseguendo le ricette su un'istanza nuova o esistente, perché potresti ottenere risultati differenti. Per creare una serie di sottodirectory, aggiungi un attributo `recursive` a `directory` e impostalo su `true`. La ricetta seguente crea `/srv/www/shared` direttamente su un'istanza pulita. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end ``` # Esempio 4: aggiunta del controllo del flusso **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disabilitato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Alcune ricette sono solo una serie di risorse Chef. In questo caso, all'esecuzione, la ricetta esegue semplicemente ciascuno dei provider di risorse in sequenza. Tuttavia, spesso è utile avere un percorso di esecuzione più sofisticato. Di seguito sono elencati due scenari comuni: + Una ricetta deve eseguire la stessa risorsa più volte con diverse impostazioni di attributo. + Vanno utilizzate diverse impostazioni di attributo su differenti sistemi operativi. È possibile affrontare situazioni come queste incorporando strutture di controllo di Ruby nella ricetta. Questa sezione spiega come modificare la ricetta da [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md) per affrontare entrambi gli scenari. **Topics** + [Iterazione](#cookbooks-101-basics-ruby-iteration) + [Logica condizionale](#cookbooks-101-basics-ruby-conditional) ## Iterazione In [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md) è stato illustrato come utilizzare una risorsa `directory` per creare una directory o serie di directory. Tuttavia, supponiamo di voler creare due diverse directory, `/srv/www/config` e `/srv/www/shared`. È possibile implementare una risorsa di directory separata per ciascuna directory, ma questo approccio può rivelarsi complesso se intendi creare molte directory. La seguente ricetta mostra un modo più semplice di gestire l'attività. ``` [ "/srv/www/config", "/srv/www/shared" ].each do |path| directory path do mode 0755 owner 'root' group 'root' recursive true action :create end end ``` Invece di utilizzare una risorsa di directory separata per ciascuna sottodirectory, la ricetta utilizza una raccolta di stringa che contiene i percorsi delle sottodirectory. Il metodo `each` di Ruby esegue la risorsa una volta per ciascun elemento della raccolta, a partire dal primo. Il valore dell'elemento è rappresentato nella risorsa dalla variabile `path`, che in questo caso rappresenta il percorso di directory. È possibile adattare questo esempio con semplicità per creare un qualsiasi numero di sottodirectory. **Per eseguire la ricetta** 1. Rimanere nella directory `createdir`; tale libro di ricette sarà utilizzato per i prossimi esempi. 1. Se non è già stato fatto, avviare `kitchen destroy` per iniziare con un'istanza pulita. 1. Sostituire il codice in `default.rb` con l'esempio ed eseguire `kitchen converge`. 1. Accedere all'istanza; la directory appena creata sarà disponibile in `/srv`. È possibile utilizzare una tabella hash per specificare due valori per ogni iterazione. La seguente ricetta crea `/srv/www/config` e `/srv/www/shared`, ognuna con una modalità diversa. ``` { "/srv/www/config" => 0644, "/srv/www/shared" => 0755 }.each do |path, mode_value| directory path do mode mode_value owner 'root' group 'root' recursive true action :create end end ``` **Per eseguire la ricetta** 1. Se non è già stato fatto, avviare `kitchen destroy` per iniziare con un'istanza pulita. 1. Sostituire il codice in `default.rb` con l'esempio ed eseguire `kitchen converge`. 1. Accedere all'istanza; la directory appena creata sarà disponibile in `/srv` con le modalità specificate. **Nota** OpsWorks Le ricette Stacks utilizzano comunemente questo approccio per estrarre valori dalla [configurazione dello stack e dalla distribuzione JSON](workingcookbook-json.md), che è fondamentalmente una grande tabella hash, e inserirli in una risorsa. Per vedere un esempio, consulta [Ricette di ditribuzione](create-custom-deploy.md). ## Logica condizionale È anche possibile usare la logica condizionale di Ruby per creare più rami di esecuzione. La seguente ricetta utilizza la logica `if-elsif-else` per estendere l'esempio precedente in modo da creare una sottodirectory denominata `/srv/www/shared`, ma solo su sistemi Ubuntu e Debian. Per tutti gli altri sistemi, registra un messaggio di errore che viene visualizzato nell'output di Test Kitchen. ``` if platform?("debian", "ubuntu") directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end else log "Unsupported system" end ``` **Per eseguire la ricetta di esempio** 1. Se l'istanza è ancora attiva, eseguire `kitchen destroy` per chiuderla. 1. Sostituire il codice in `default.rb` con il codice di esempio. 1. Modificare `.kitchen.yml` per aggiungere un sistema CentOS 6.4 all'elenco delle piattaforme. La sezione `platforms` del file avrà adesso un aspetto simile al seguente. ``` ... platforms: - name: ubuntu-12.04 - name: centos-6.4 ... ``` 1. Eseguire `kitchen converge`, che consente di creare un'istanza ed eseguire le ricette per ogni piattaforma in `.kitchen.yml`, in sequenza. **Nota** Per convergere una sola istanza, aggiungere il nome dell'istanza come parametro. Ad esempio, per convergere la ricetta solo sulla piattaforma Ubuntu, eseguire `kitchen converge default-ubuntu-1204`. In caso di dimenticanza dei nomi della piattaforma, basta eseguire `kitchen list`. Il messaggio di log dovrebbe essere visualizzato nella parte riservata a CentOS dell'output di Test Kitchen, che sarà simile alla seguente: ``` ... Converging 1 resources Recipe: createdir::default * log[Unsupported system] action write[2014-06-23T19:10:30+00:00] INFO: Processing log[Unsupported system] action write (createdir::default line 12) [2014-06-23T19:10:30+00:00] INFO: Unsupported system [2014-06-23T19:10:30+00:00] INFO: Chef Run complete in 0.004972162 seconds ``` Ora puoi accedere alle istanze e verificare se le directory sono state create o meno. Tuttavia, non puoi eseguire semplicemente `kitchen login` ora. Devi specificare l'istanza aggiungendo il nome della piattaforma, ad esempio `kitchen login default-ubuntu-1204` . **Nota** Se un comando Test Kitchen richiede un nome di istanza, non è necessario digitare il nome completo. Test Kitchen considera il nome di un'istanza come espressione regolare di Ruby, perciò serve solo un numero di caratteri sufficiente a fornire una corrispondenza univoca. Ad esempio, è possibile convergere la sola istanza Ubuntu eseguendo `kitchen converge ub` o accedendo all'istanza CentOS eseguendo `kitchen login 64`. A questo punto probabilmente ti starai chiedendo come fa la ricetta a sapere su quale piattaforma è in esecuzione. Per ogni sessione, Chef esegue uno strumento chiamato [Ohai](https://docs.chef.io/ohai.html) che raccoglie i dati di sistema, tra cui la piattaforma, e li rappresenta come una serie di attributi in una struttura chiamata *nodo oggetto*. Il metodo `platform?` di Chef confronta i sistemi tra parentesi con il valore della piattaforma Ohai e restituisce true in caso di corrispondenza. È possibile fare riferimento al valore di un attributo di nodo direttamente nel codice utilizzando `node['attribute_name']`. Il valore della piattaforma, ad esempio, è rappresentato da `node['platform']`. È possibile, ad esempio, aver scritto l'esempio precedente come segue. ``` if node[:platform] == 'debian' or node[:platform] == 'ubuntu' directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end else log "Unsupported system" end ``` Un motivo comune per includere una logica condizionale in una ricetta si basa sul fatto che diverse famiglie Linux talvolta utilizzano nomi diversi per pacchetti, directory e così via. Ad esempio, il nome del pacchetto Apache è `httpd` sui sistemi CentOS e `apache2` sui sistemi Ubuntu. Se serve solo un'altra stringa per diversi sistemi, il metodo [http://docs.chef.io/dsl_recipe.html#value-for-platform](http://docs.chef.io/dsl_recipe.html#value-for-platform) di Chef è una soluzione più semplice rispetto a `if-elsif-else`. La seguente ricetta crea una directory `/srv/www/shared` su sistemi CentOS, una directory `/srv/www/data` su sistemi Ubuntu e `/srv/www/config` su tutti gli altri. ``` data_dir = value_for_platform( "centos" => { "default" => "/srv/www/shared" }, "ubuntu" => { "default" => "/srv/www/data" }, "default" => "/srv/www/config" ) directory data_dir do mode 0755 owner 'root' group 'root' recursive true action :create end ``` `value_for_platform` assegna il percorso appropriato a `data_dir` e la risorsa `directory` utilizza tale valore per creare la directory. **Per eseguire la ricetta di esempio** 1. Se l'istanza è ancora attiva, eseguire `kitchen destroy` per chiuderla. 1. Sostituire il codice in `default.rb` con il codice di esempio. 1. Esegui `kitchen converge` e quindi accedere a ogni istanza per verificare che siano presenti le directory appropriate. # Esempio 5: utilizzo di attributi **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Le ricette nelle sezioni precedenti utilizzavano valori prefissati per tutto, tranne che per la piattaforma. Questo approccio può rivelarsi poco pratico se, ad esempio, vuoi utilizzare lo stesso valore in più ricette. Puoi definire i valori separatamente dalle ricette includendo un file attributo nel tuo libro di ricette. Un file attributo è un'applicazione Ruby che assegna valori a uno o più attributi. deve trovarsi nella cartella `attributes` del libro di ricette. Chef incorpora gli attributi nell'oggetto nodo e qualsiasi ricetta può utilizzare i valori dell'attributo facendovi riferimento. Questo argomento spiega come modificare la ricetta da [Iterazione](cookbooks-101-basics-ruby.md#cookbooks-101-basics-ruby-iteration) per utilizzare gli attributi. Ecco la ricetta originale come riferimento. ``` [ "/srv/www/config", "/srv/www/shared" ].each do |path| directory path do mode 0755 owner 'root' group 'root' recursive true action :create end end ``` Di seguito vengono determinati gli attributi per il nome della sottodirectory, la modalità, il proprietario e i valori di gruppo. ``` default['createdir']['shared_dir'] = 'shared' default['createdir']['config_dir'] = 'config' default['createdir']['mode'] = 0755 default['createdir']['owner'] = 'root' default['createdir']['group'] = 'root' ``` Tenere presente quanto segue: + Ogni definizione inizia con un *tipo di attributo*. Se un attributo viene definito più di una volta, magari in file di attributi diversi, il tipo di attributo specifica la precedenza dell'attributo, che determina quale definizione è incorporata nell'oggetto nodo. Per ulteriori informazioni, consulta [Precedenza degli attributi](workingcookbook-attributes-precedence.md). Tutte le definizioni in questo esempio hanno il tipo di attributo `default`, che è l'opzione più comune per questo scopo. + Gli attributi hanno nomi nidificati. L'oggetto nodo è fondamentalmente una tabella hash che può essere nidificata con profondità arbitraria, perciò i nomi di attributo possono essere nidificati ed è comune che lo siano. Questo file attributo segue una pratica standard, ovvero l'utilizzo di un nome nidificato con il nome del libro di ricette, `createdir`, come primo elemento. L'utilizzo di createdir come primo elemento dell'attributo è dovuto al fatto che Chef, durante l'esecuzione di una sessione, incorpora gli attributi di ogni libro di ricette nell'oggetto nodo. Con OpsWorks Stacks, l'oggetto node include un gran numero di attributi dei libri di [cucina incorporati](https://github.com/aws/opsworks-cookbooks) oltre a tutti gli attributi definiti dall'utente. Includere il nome del libro di ricette nel nome dell'attributo riduce il rischio di un conflitto di nomi con gli attributi di un altro libro di ricette, soprattutto se l'attributo ha un nome come `port` o `user`. Non assegnare a un attributo un nome del tipo [`[:apache2][:user]`](attributes-recipes-apache.md#attributes-recipes-apache-user), ad esempio, a meno di voler sovrascrivere il valore di tale attributo. Per ulteriori informazioni, consulta [Utilizzo degli attributi personalizzati del libro di ricette](workingcookbook-cookbook-attributes.md). L'esempio seguente mostra la ricetta originale con gli attributi invece che con i valori prefissati. ``` [ "/srv/www/#{node['createdir']['shared_dir']}", "/srv/www/#{node['createdir']['config_dir']}" ].each do |path| directory path do mode node['createdir']['mode'] owner node['createdir']['owner'] group node['createdir']['group'] recursive true action :create end end ``` **Nota** Se vuoi incorporare un valore attributo in una stringa, includilo fra `#{}`. Nell'esempio precedente, `#{node['createdir']['shared_dir']}` aggiunge "shared" a "/srv/www/". **Per eseguire la ricetta** 1. Eseguire `kitchen destroy` per iniziare con un'istanza pulita. 1. Sostituire il codice in `recipes/default.rb` con l'esempio della ricetta precedente. 1. Creare una sottodirectory di `createdir` denominata `attributes` e aggiungere un file con nome `default.rb` che contiene le definizioni degli attributi. 1. Modificare `.kitchen.yml` per rimuovere CentOS dall'elenco delle piattaforme. 1. Eseguire `kitchen converge`, effettuare l'accesso all'istanza e verificare la presenza di `/srv/www/shared` e `/srv/www/config`. **Nota** Con OpsWorks Stacks, la definizione dei valori come attributi offre un ulteriore vantaggio; puoi utilizzare [JSON personalizzato](workingstacks-json.md) per sovrascrivere tali valori in base allo stack o anche alla distribuzione. Questa possibilità può essere utile per molti scopi, ad esempio: È possibile personalizzare il comportamento delle ricette, ad esempio le impostazioni di configurazione o i nomi utente, senza dover modificare il libro di ricette. È possibile, ad esempio, utilizzare lo stesso libro di ricette per diversi stack e utilizzare un JSON personalizzato per specificare le impostazioni di configurazione chiave per un determinato stack. Questo consente di risparmiare il tempo e il lavoro necessari per modificare il libro di ricette o utilizzare un diverso libro di ricette per ogni stack. Non inserire informazioni potenzialmente riservate, ad esempio le password del database, nel repository del libro di ricette. Puoi utilizzare un attributo per definire un valore di default e quindi utilizzare JSON personalizzati per sovrascrivere quel valore con quello reale. Per ulteriori informazioni sull'utilizzo di JSON personalizzati per sovrascrivere gli attributi, consulta [Sostituzione degli attributi](workingcookbook-attributes.md). Il file attributo è denominato `default.rb` perché è un'applicazione Ruby, anche se semplice. Ciò significa che è possibile, ad esempio, utilizzare la logica condizionale per specificare valori degli attributi in base al sistema operativo. In [Logica condizionale](cookbooks-101-basics-ruby.md#cookbooks-101-basics-ruby-conditional), hai specificato nella ricetta un nome di sottodirectory diverso per differenti famiglie Linux. Un file attributo, invece, ti consente di inserire la logica condizionale nel file attributo stesso. Il seguenti file attributo impiega `value_for_platform` per specificare un valore di attributo `['shared_dir']` diverso a seconda del sistema operativo. Per altre condizioni, puoi usare la logica `if-elsif-else` di Ruby o un'istruzione `case`. ``` data_dir = value_for_platform( "centos" => { "default" => "shared" }, "ubuntu" => { "default" => "data" }, "default" => "user_data" ) default['createdir']['shared_dir'] = data_dir default['createdir']['config_dir'] = "config" default['createdir']['mode'] = 0755 default['createdir']['owner'] = 'root' default['createdir']['group'] = 'root' ``` **Per eseguire la ricetta** 1. Eseguire `kitchen destroy` per iniziare con un'istanza nuova. 1. Sostituire il codice in `attributes/default.rb` con l'esempio precedente. 1. Modificare `.kitchen.yml` per aggiungere una piattaforma CentOS alla sezione delle piattaforme, come descritto in [Logica condizionale](cookbooks-101-basics-ruby.md#cookbooks-101-basics-ruby-conditional). 1. Eseguire `kitchen converge` e quindi effettuare l'accesso alle istanze per verificare la presenza delle directory. Al termine dell'operazione, eseguire `kitchen destroy` per terminare l'istanza. L'esempio successivo utilizza un nuovo libro di ricette. # Esempio 6: creazione di file **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Dopo aver creato le directory, spesso è necessario aggiungervi file di configurazione, file di dati e così via. Questo argomento mostra due modi per installare i file su un'istanza. **Topics** + [Installazione di un file da un libro di ricette](#cookbooks-101-basics-files-cookbook_file) + [Creazione di un file da un modello](#cookbooks-101-basics-files-template) ## Installazione di un file da un libro di ricette Il modo più semplice di installare un file su un'istanza è utilizzando una risorsa [https://docs.chef.io/chef/resources.html#cookbook-file](https://docs.chef.io/chef/resources.html#cookbook-file), che copia un file dal libro di ricette a un percorso specificato sull'istanza, per sistemi sia Linux che Windows. Questo esempio estende la ricetta da [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md) per aggiungere un file di dati `/srv/www/shared` dopo la creazione della directory. Ecco la ricetta originale come riferimento. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end ``` **Per configurare il libro di ricette** 1. Nella directory `opsworks_cookbooks`, creare una directory denominata `createfile` e aprirla. 1. Aggiungere un file `metadata.rb` a `createfile` con il contenuto seguente. ``` name "createfile" version "0.1.0" ``` 1. Inizializzare e configurare Test Kitchen come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md), quindi rimuovere CentOS dall'elenco `platforms`. 1. Aggiungere la sottodirectory `recipes` a `createfile`. Il file da installare contiene i seguenti dati JSON. ``` { "my_name" : "myname", "your_name" : "yourname", "a_number" : 42, "a_boolean" : true } ``` **Per configurare il file di dati** 1. Aggiungere la sottodirectory `files` a `createfile` e la sottodirectory `default` a `files`. Qualsiasi file installato con `cookbook_file` deve trovarsi in una sottodirectory di `files`, come `files/default` in questo esempio. **Nota** Per specificare diversi file per sistemi differenti, è possibile inserire ogni file specifico in una sottocartella denominata secondo il sistema, ad esempio `files/ubuntu`. La risorsa `cookbook_file` copia l'appropriato file specifico per il sistema, se esistente, altrimenti utilizza il file `default`. Per ulteriori informazioni, consulta [cookbook\$1file](https://docs.chef.io/chef/resources.html#cookbook-file). 1. Creare un file denominato `example_data.json` con il JSON dell'esempio precedente e aggiungerlo a `files/default`. La seguente ricetta copia `example_data.json` in un percorso specificato. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end cookbook_file "/srv/www/shared/example_data.json" do source "example_data.json" mode 0644 action :create_if_missing end ``` Dopo che la risorsa della directory crea `/srv/www/shared`, la risorsa `cookbook_file` copia `example_data.json` in tale directory e imposta anche l'utente, il gruppo e la modalità del file. **Nota** La risorsa `cookbook_file` introduce una nuova operazione: `create_if_missing`. È inoltre possibile utilizzare un'operazione `create`, che però sovrascrive un file esistente. Se non si desidera sovrascrivere nulla, utilizzare `create_if_missing`, che installa `example_data.json` solo se non è già esistente. **Per eseguire la ricetta** 1. Eseguire `kitchen destroy` per iniziare con un'istanza nuova. 1. Creare un file `default.rb` che contiene la ricetta precedente e salvarlo in `recipes`. 1. Eseguire `kitchen converge`, quindi accedere all'istanza per verificare che `/srv/www/shared` contenga `example_data.json`. ## Creazione di un file da un modello La risorsa `cookbook_file` è utile per alcuni scopi, ma si limita a installare qualsiasi file presente nel libro di ricette. Una risorsa [https://docs.chef.io/chef/resources.html#template](https://docs.chef.io/chef/resources.html#template) offre un modo più flessibile di installare un file su un'istanza di Windows o Linux tramite creazione dinamica da un modello. È quindi possibile determinare i dettagli del contenuto del file in fase di runtime e apportare modifiche in base alle esigenze. Ad esempio, potresti volere che un file di configurazione abbia una determinata impostazione all'avvio dell'istanza per poi modificare l'impostazione in seguito all'aggiunta di altre istanze allo stack. Questo esempio modifica il libro di ricette `createfile` perché sia utilizzata una risorsa `template` per installare una versione di `example_data.json` leggermente modificata. Ecco come apparirà il file installato. ``` { "my_name" : "myname", "your_name" : "yourname", "a_number" : 42, "a_boolean" : true, "a_string" : "some string", "platform" : "ubuntu" } ``` Le risorse del modello sono in genere utilizzate in combinazione con i file attributo, quindi l'esempio ne utilizza uno per definire i seguenti valori. ``` default['createfile']['my_name'] = 'myname' default['createfile']['your_name'] = 'yourname' default['createfile']['install_file'] = true ``` **Per configurare il libro di ricette** 1. Eliminare la directory `createfile` del libro di ricette `files` e il relativo contenuto. 1. Aggiungere la sottodirectory `attributes` a `createfile` e aggiungere a `default.rb` il file `attributes` che contiene le definizioni degli attributi precedenti. Un modello è un file `.erb` che è fondamentalmente una copia del file finale, con alcuni dei contenuti rappresentati da segnaposti. Quando la risorsa `template` crea il file, copia i contenuti del modello nel file specificato e sovrascrive i segnaposto con i relativi valori assegnati. Ecco il modello per `example_data.json`. ``` { "my_name" : "<%= node['createfile']['my_name'] %>", "your_name" : "<%= node['createfile']['your_name'] %>", "a_number" : 42, "a_boolean" : <%= @a_boolean_var %>, "a_string" : "<%= @a_string_var %>", "platform" : "<%= node['platform'] %>" } ``` I valori `<%=...%>` sono i segnaposto. + `<%=node[...]%>` rappresenta un nodo valore attributo. In questo esempio, il valore "your\$1name" è un segnaposto che rappresenta uno dei valori attributo del file attributo del libro di ricette. + `<%=@...%>` rappresenta il valore di una variabile definita nella risorsa del modello, come illustreremo più avanti. **Per creare il file del modello** 1. Aggiungere la sottodirectory `templates` al libro di ricette `createfile` e la sottodirectory `default` a `templates`. **Nota** La directory `templates` funziona in modo analogo alla directory `files`. È possibile inserire modelli specifici per il sistema in una sottodirectory, ad esempio `ubuntu`, con nome assegnato a seconda del sistema. La risorsa `template` usa l'appropriato modello specifico per il sistema, se esistente, altrimenti utilizza il modello `default`. 1. Creare un file denominato `example_data.json.erb` e salvarlo nella directory `templates/default`. Il nome del modello è arbitrario, ma è in genere si crea aggiungendo `.erb` al nome del file, incluse le estensioni. La seguente ricetta utilizza una risorsa `template` per creare `/srv/www/shared/example_data.json`. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end template "/srv/www/shared/example_data.json" do source "example_data.json.erb" mode 0644 variables( :a_boolean_var => true, :a_string_var => "some string" ) only_if {node['createfile']['install_file']} end ``` La risorsa `template` crea `example_data.json` da un modello e lo installa in `/srv/www/shared`. + Il nome del modello, `/srv/www/shared/example_data.json`, specifica il percorso e il nome del file installato. + L'attributo `source` specifica il modello utilizzato per creare il file. + L'attributo `mode` specifica la modalità di installazione del file. + La risorsa definisce due variabili: `a_boolean_var` e `a_string_var`. Quando la risorsa crea `example_data.json`, sovrascrive la variabile segnaposto del modello con i valori corrispondenti della risorsa. + L'attributo di `only_if`protezione* * indica alla risorsa di creare il file solo se `['createfile']['install_file']` è impostato su `true`. **Per eseguire la ricetta** 1. Eseguire `kitchen destroy` per iniziare con un'istanza nuova. 1. Sostituire il codice in `recipes/default.rb` con l'esempio precedente. 1. Eseguire `kitchen converge`, quindi effettuare l'accesso all'istanza per verificare che il file sia presente in `/srv/www/shared` con i contenuti corretti. Al termine dell'operazione, eseguire `kitchen destroy` per chiudere l'istanza. La sezione successiva utilizza un nuovo libro di ricette. # Esempio 7: esecuzione di comandi e script **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Le risorse di Chef possono gestire un'ampia gamma di attività su un'istanza, ma talvolta è preferibile usare un comando shell o uno script. Ad esempio, se hai già script che utilizzi per eseguire determinate attività, sarà più semplice continuare a utilizzar questi ultimi, piuttosto che implementare un nuovo codice. Questa sezione illustra come eseguire comandi o script in un'istanza. **Topics** + [Esecuzione di comandi](#cookbooks-101-basics-commands-script) + [Esecuzione di script](#cookbooks-101-basics-commands-execute) ## Esecuzione di comandi La risorsa [https://docs.chef.io/chef/resources.html#script](https://docs.chef.io/chef/resources.html#script) esegue uno o più comandi. Supporta gli interpreti di comandi csh, bash, Perl, Python e Ruby, quindi può essere utilizzato sia su sistemi Linux che Windows, purché vi sia installato l'opportuno interprete. Questo argomento illustra come eseguire un semplice comando bash su un'istanza Linux. Chef supporta anche le risorse [powershell\$1script](https://docs.chef.io/chef/resources.html#powershell-script) e [batch](https://docs.chef.io/chef/resources.html#batch) per l'esecuzione di script su Windows. Per ulteriori informazioni, consulta [Esecuzione di uno PowerShell script di Windows](cookbooks-101-opsworks-opsworks-powershell.md). **Per iniziare** 1. Nella directory `opsworks_cookbooks`, creare una directory denominata `script` e aprirla. 1. Aggiungere un file `metadata.rb` a `script` con il contenuto seguente. ``` name "script" version "0.1.0" ``` 1. Inizializzare e configurare Test Kitchen come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md), quindi rimuovere CentOS dall'elenco `platforms`. 1. In `script`, creare una directory denominata `recipes`. È possibile eseguire comandi utilizzando la stessa risorsa `script`, ma Chef supporta anche un set di versioni della risorsa specifico per interprete di comandi; tali versioni vengono denominate a seconda dell'interprete. La seguente ricetta utilizza una risorsa [https://docs.chef.io/chef/resources.html#bash](https://docs.chef.io/chef/resources.html#bash) per eseguire un semplice script bash. ``` bash "install_something" do user "root" cwd "/tmp" code <<-EOH touch somefile EOH not_if do File.exists?("/tmp/somefile") end end ``` La risorsa `bash` è configurata come segue. + Utilizza l'operazione di default, `run`, che esegue i comandi nel blocco `code`. Questo esempio contiene un solo comando, `touch somefile`ma un blocco `code` può contenere più comandi. + L'attributo `user` specifica l'utente che esegue il comando. + L'attributo `cwd` specifica la directory di lavoro. Per questo esempio, `touch` crea un file nella directory `/tmp`. + L'attributo di protezione `not_if` indica alla risorsa di non eseguire alcuna operazione se il file è già esistente. **Per eseguire la ricetta** 1. Creare un file `default.rb` che contiene il codice di esempio precedente e salvarlo in `recipes`. 1. Eseguire `kitchen converge`, quindi accedere all'istanza per verificare che il file sia presente in `/tmp`. ## Esecuzione di script La risorsa `script` è pratica, soprattutto se hai bisogno di eseguire solo uno o due comandi; spesso è però preferibile archiviare lo script in un file ed eseguire il file stesso. La risorsa [https://docs.chef.io/chef/resources.html#execute](https://docs.chef.io/chef/resources.html#execute) esegue uno specifico file eseguibile, inclusi i file di script, in Linux o Windows. Questo argomento modifica il libro di ricette `script` dell'esempio precedente per usare `execute` al fine di eseguire un semplice script shell. È possibile estendere facilmente l'esempio a script più complessi o ad altri tipi di file eseguibile. **Per configurare il file script** 1. Aggiungere la sottodirectory `files` a `script` e la sottodirectory `default` a `files`. 1. Creare un file denominato `touchfile` che contenga quando segue e aggiungerlo a `files/default`. In questo esempio viene utilizzata una comune riga di interpretazione Bash, ma puoi sostituire l'interprete con quello più adatto al tuo ambiente shell, se necessario. ``` #!/usr/bin/env bash touch somefile ``` Il file script può contenere un numero qualsiasi di comandi. Per comodità, questo script di esempio include un solo comando `touch`. La seguente ricetta esegue lo script. ``` cookbook_file "/tmp/touchfile" do source "touchfile" mode 0755 end execute "touchfile" do user "root" cwd "/tmp" command "./touchfile" end ``` La risorsa `cookbook_file` copia il file script su `/tmp` e imposta la modalità per rendere il file eseguibile. La risorsa `execute` esegue quindi il file come indicato di seguito: + L'attributo `user` specifica l'utente del comando (`root` in questo esempio). + L'attributo `cwd` specifica la directory di lavoro (`/tmp` in questo esempio). + L'attributo `command` specifica lo script da eseguire (`touchfile` in questo esempio), che si trova nella directory di lavoro. **Per eseguire la ricetta** 1. Sostituire il codice in `recipes/default.rb` con l'esempio precedente. 1. Eseguire `kitchen converge`, quindi effettuare l'accesso all'istanza per verificare che `/tmp` ora contenga il file script, con la modalità impostata su 0755, e `somefile`. Al termine dell'operazione, eseguire `kitchen destroy` per chiudere l'istanza. La sezione successiva utilizza un nuovo libro di ricette. # Esempio 8: gestione dei servizi **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). I pacchetti, ad esempio i server delle applicazioni, in genere hanno associato un servizio che deve essere avviato, arrestato, riavviato e così via. Ad esempio, è necessario avviare il servizio Tomcat dopo l'installazione del pacchetto o dopo il termine del processo di avvio dell'istanza e riavviare il servizio a ogni modifica del file di configurazione. In questo argomento vengono illustrati i concetti di base per la gestione di un servizio su un'istanza Linux, utilizzando un server delle applicazioni Tomcat come esempio. La risorsa service funziona quasi nello stesso modo sulle istanze Windows, anche se vi sono alcune differenze nei dettagli. Per ulteriori informazioni, consulta [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service). **Nota** L'esempio prevede un'installazione minima di Tomcat, quanto basta per illustrare le procedure fondamentali per l'utilizzo di una risorsa `service`. Per un esempio di come implementare ricette per un server Tomcat più funzionale, consulta [Creazione di un livello server Tomcat personalizzato](create-custom.md). **Topics** + [Definizione e avvio di un servizio](#cookbooks-101-basics-services-service) + [Utilizzo di notifies per avviare o riavviare un servizio](#cookbooks-101-basics-services-notifies) ## Definizione e avvio di un servizio Questa sezione mostra i concetti di base per definire e avviare un servizio. **Per iniziare** 1. Nella directory `opsworks_cookbooks`, creare una directory denominata `tomcat` e aprirla. 1. Aggiungere un file `metadata.rb` a `tomcat` con il contenuto seguente. ``` name "tomcat" version "0.1.0" ``` 1. Inizializzare e configurare Test Kitchen come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md), quindi rimuovere CentOS dall'elenco `platforms`. 1. Aggiungere la sottodirectory `recipes` a `tomcat`. La gestione del servizio avviene tramite una risorsa [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service). La seguente ricetta di default installa Tomcat e avvia il servizio. ``` execute "install_updates" do command "apt-get update" end package "tomcat7" do action :install end include_recipe 'tomcat::service' service 'tomcat' do action :start end ``` La ricetta effettua le seguenti operazioni: + La risorsa `execute` esegue `apt-get update` per installare gli aggiornamenti correnti del sistema. Per l'istanza di Ubuntu utilizzata in questo esempio, è necessario installare gli aggiornamenti prima di installare Tomcat. Altri sistemi possono avere requisiti diversi. + La risorsa `package` installa Tomcat 7. + La ricetta `tomcat::service` inclusa definisce il servizio e verrà discussa più avanti. + La risorsa `service` avvia il servizio Tomcat. È anche possibile usare questa risorsa per l'esecuzione di altri comandi, ad esempio per interrompere e riavviare il servizio. L'esempio seguente illustra la ricetta `tomcat::service`. ``` service 'tomcat' do service_name "tomcat7" supports :restart => true, :reload => false, :status => true action :nothing end ``` Questa ricetta crea la definizione del servizio Tomcat come segue: + Il nome della risorsa, `tomcat`, viene utilizzato da altre ricette per fare riferimento al servizio. Ad esempio, `default.rb` fa riferimento a `tomcat` per avviare il servizio. + La risorsa `service_name` specifica il nome del servizio. Nell'elenco dei servizi per l'istanza, il servizio Tomcat sarà denominato tomcat7. + `supports` specifica come Chef gestisce i comandi `restart`, `reload` e `status` del servizio. + `true` indica che Chef può utilizzare lo script init o un altro provider di servizi per eseguire il comando. + `false` indica che Chef deve tentare di eseguire il comando con altri mezzi. Osserva che `action` è impostato su `:nothing`, che indica alla risorsa di non eseguire alcuna operazione. La risorsa service supporta azioni quali `start` e `restart`. Tuttavia, questo libro di ricette segue una pratica standard: l'utilizzo della definizione di un servizio che non richiede alcun intervento con avvio o riavvio del servizio altrove. Ogni ricetta che avvia o riavvia un servizio deve prima definirlo, perciò l'approccio più semplice è indicare in una ricetta separata la definizione del servizio e includerla in altre ricette in base alle esigenze. **Nota** Per semplicità, la ricetta di default per questo esempio utilizza una risorsa `service` per avviare il servizio dopo aver eseguito la definizione del servizio. Un'implementazione di produzione in genere avvia o riavvia un servizio utilizzando `notifies`, come illustrato più avanti. **Per eseguire la ricetta** 1. Creare un file `default.rb` che contiene l'esempio di ricetta predefinita e salvarlo in `recipes`. 1. Creare un file `service.rb` che contiene l'esempio di definizione del servizio e salvarlo in `recipes`. 1. Eseguire `kitchen converge`, quindi effettuare l'accesso all'istanza ed eseguire il comando seguente per verificare che il servizio sia in esecuzione. ``` sudo service tomcat7 status ``` **Nota** Se `service.rb` era in esecuzione separatamente da `default.rb`, è necessario modificare `.kitchen.yml` per aggiungere `tomcat::service` all'elenco di esecuzione. Tuttavia, quando si include una ricetta, il relativo codice viene incorporato nella ricetta padre prima che la ricetta viene eseguita. `service.rb` è quindi fondamentalmente una parte di `default.rb` e non richiede un elenco di esecuzione separato. ## Utilizzo di notifies per avviare o riavviare un servizio Di solito, le implementazioni di produzione non utilizzano `service` per avviare o riavviare un servizio. Al contrario, aggiungono `notifies` a una qualsiasi delle diverse risorse. Ad esempio, se vuoi riavviare il servizio dopo la modifica di un file di configurazione, includi `notifies` nella risorsa `template` associata. L'utilizzo di `notifies` presenta i seguenti vantaggi rispetto all'utilizzo di una risorsa `service` per il riavvio esplicito del servizio. + L'elemento `notifies` riavvia il servizio solo se il file di configurazione associato è stato modificato, eliminando ogni rischio di riavvii superflui del servizio. + Chef riavvia il servizio al massimo una volta al termine di ogni sessione, indipendentemente dal numero di `notifies` contenuti nell'esecuzione. Ad esempio, un'esecuzione Chef può includere più risorse di modelli, ciascuna delle quali modifica un file di configurazione differente e richiede il riavvio del servizio se il file è stato modificato. Tuttavia, in genere è preferibile riavviare il servizio solo una volta, alla fine dell'esecuzione Chef. In caso contrario, può succedere che si tenti di riavviare un servizio non ancora completamente operativo da un riavvio precedente, il che può causare errori. In questo esempio viene modificato `tomcat::default` per includere una risorsa `template` che utilizza `notifies` per riavviare il servizio. Un esempio realistico potrebbe utilizzare una risorsa template che crea una versione personalizzata di uno dei file di configurazione Tomcat, che sono però alquanto lunghi e complessi. Per semplicità, l'esempio usa soltanto la risorsa template da [Creazione di un file da un modello](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template). Non ha niente a che fare con Tomcat, ma consente di illustrare in modo semplice come utilizzare `notifies`. Per un esempio che illustri come utilizzare i modelli per creare file di configurazione Tomcat, consulta [Ricette di impostazione](create-custom-setup.md). **Per configurare il libro di ricette** 1. Aggiungere la sottodirectory `templates` a `tomcat` e la sottodirectory `default` a `templates`. 1. Copiare il modello `example_data.json.erb` dal libro di ricette `createfile` nella directory `templates/default`. 1. Aggiungere la sottodirectory `attributes` a `tomcat`. 1. Copiare il file attributo `default.rb` dal libro di ricette `createfile` nella directory `attributes`. La seguente ricetta utilizza `notifies` per riavviare il servizio Tomcat. ``` execute "install_updates" do command "apt-get update" end package "tomcat7" do action :install end include_recipe 'tomcat::service' service 'tomcat' do action :enable end directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end template "/srv/www/shared/example_data.json" do source "example_data.json.erb" mode 0644 variables( :a_boolean_var => true, :a_string_var => "some string" ) only_if {node['createfile']['install_file']} notifies :restart, resources(:service => 'tomcat') end ``` L'esempio unisce la ricetta di [Creazione di un file da un modello](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template) e la ricetta della sezione precedente, con due modifiche rilevanti: + La risorsa `service` è ancora presente, ma con uno scopo leggermente diverso. L'operazione `:enable` abilita il servizio Tomcat all'avvio. + La risorsa template ora include `notifies`, che riavvia il servizio Tomcat se `example_data.json` è stato modificato. Questo garantisce che il servizio venga avviato quando alla prima installazione di Tomcat e riavviato dopo ogni modifica alla configurazione. **Per eseguire la ricetta** 1. Eseguire `kitchen destroy` per iniziare con un'istanza pulita. 1. Sostituire il codice in `default.rb` con l'esempio precedente. 1. Eseguire `kitchen converge`, quindi accedere all'istanza e verificare che il servizio sia in esecuzione. **Nota** Se si desidera riavviare un servizio ma la ricetta non include una risorsa, ad esempio `template` che supporta `notifies`, è possibile utilizzare una risorsa fittizia `execute`. Ad esempio ``` execute 'trigger tomcat service restart' do command 'bin/true' notifies :restart, resources(:service => 'tomcat') end ``` La risorsa `execute` deve avere un attributo `command`, anche se viene utilizzata solo come modo per eseguire `notifies`. Questo esempio aggira quel requisito eseguendo `/bin/true`, un comando shell che restituisce semplicemente un codice di riuscita. # Esempio 9: utilizzo di Amazon EC2 Instances **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Fino a questo punto, hai eseguito istanze localmente in. VirtualBox Sebbene sia semplice e veloce, alla fine vorrai testare le tue ricette su un' EC2 istanza Amazon. In particolare, se desideri eseguire ricette su Amazon Linux, è disponibile solo su Amazon EC2. Puoi utilizzare un sistema simile come CentOS per l'implementazione e i test preliminari, ma l'unico modo per testare completamente le tue ricette su Amazon Linux è con un'istanza Amazon EC2 . Questo argomento mostra come eseguire ricette su un' EC2 istanza Amazon. Utilizzerai Test Kitchen e Vagrant come nelle sezioni precedenti, con due differenze: + Il driver è [https://rubygems.org/gems/kitchen-ec2](https://rubygems.org/gems/kitchen-ec2) invece di Vagrant. + Il `.kitchen.yml` file del ricettario deve essere configurato con le informazioni necessarie per avviare l' EC2 istanza Amazon. **Nota** In alternativa, è possibile utilizzare il plug-in Vagrant `vagrant-aws`. Par maggiori informazioni, consulta la pagina sul [provider AWS Vagrant](https://github.com/mitchellh/vagrant-aws). Avrai bisogno delle credenziali AWS per creare un' EC2 istanza Amazon. Se non hai già un account AWS, puoi crearne uno procedendo come segue. ## Registrati per un Account AWS Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno. **Per iscriverti a un Account AWS** 1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup) 1. Segui le istruzioni online. Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono. Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**. ## Crea un utente con accesso amministrativo Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane. **Proteggi i tuoi Utente root dell'account AWS** 1. Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password. Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *. 1. Abilita l’autenticazione a più fattori (MFA) per l’utente root. Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*. **Crea un utente con accesso amministrativo** 1. Abilita il Centro identità IAM. Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *. 1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente. Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com/singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*. **Accesso come utente amministratore** + Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM. Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*. **Assegnazione dell’accesso ad altri utenti** 1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo. Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com/singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *. 1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On). Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com/singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *. Dovresti [creare un utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html) con le autorizzazioni per accedere ad Amazon EC2 e salvare l'accesso e le chiavi segrete dell'utente in una posizione sicura sulla tua workstation. Test Kitchen utilizzerà le credenziali per creare l'istanza. Il modo migliore per fornire le credenziali a Test Kitchen è assegnare le chiavi alle seguenti variabili di ambiente nella workstation. **avvertimento** Gli utenti IAM dispongono di credenziali a lungo termine, il che rappresenta un rischio per la sicurezza. Per ridurre questo rischio, si consiglia di fornire a questi utenti solo le autorizzazioni necessarie per eseguire l'attività e di rimuoverli quando non sono più necessari. + AWS\$1ACCESS\$1KEY — la chiave di accesso dell'utente, che avrà un aspetto simile. AKIAIOSFODNN7EXAMPLE + AWS\$1SECRET\$1KEY — la chiave segreta del tuo utente, che avrà un aspetto similewJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY. Grazie a questo approccio, si riducono le possibilità di compromettere accidentalmente l'account aziendale, ad esempio caricando un progetto contenente le credenziali in un repository pubblico. **Per configurare il libro di ricette** 1. Per usare il driver `kitchen-ec2`, è necessario disporre del pacchetto `ruby-dev` installato nel sistema. L'esempio seguente mostra come usare il comando `aptitude` per installare il pacchetto su un sistema Ubuntu. ``` sudo aptitude install ruby1.9.1-dev ``` 1. Il driver `kitchen-ec2` è un pacchetto gem, che è possibile installare come segue: ``` gem install kitchen-ec2 ``` A seconda della workstation, questo comando può richiedere `sudo` oppure è possibile anche utilizzare un gestore di ambiente Ruby come [RVM](https://rvm.io/). Questa procedura è stata testata con versione 0.8.0 del driver `kitchen-ec2`, ma sono disponibili versioni più recenti. Per installare una [versione specifica](https://rubygems.org/gems/kitchen-ec2/versions), eseguire `gem install kitchen-ec2 -v `. 1. Devi specificare una coppia di chiavi Amazon EC2 SSH che Test Kitchen può utilizzare per connettersi all'istanza. Se non disponi di una coppia di EC2 chiavi Amazon, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) per informazioni su come crearne una. La coppia di chiavi deve appartenere alla stessa regione AWS dell'istanza. L'esempio utilizza Stati Uniti occidentali (California settentrionale). Dopo aver selezionato una coppia di chiavi, creare una sottodirectory di `opsworks_cookbooks` denominata `ec2_keys` e copiare il file della chiave privata della coppia di chiavi (`.pem`) in tale sottodirectory. La chiave privata è stata inserita in `ec2_keys` solo per comodità per semplificare il codice, ma può trovarsi ovunque sul tuo sistema. 1. Creare una sottodirectory di `opsworks_cookbooks` denominata `createdir-ec2` e accedervi. 1. Aggiungere un file `metadata.rb` a `createdir-ec2` con il contenuto seguente. ``` name "createdir-ec2" version "0.1.0" ``` 1. Inizializzare Test Kitchen, come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md). La sezione seguente descrive come eseguire la configurazione`.kitchen.yml`, che è molto più complicata per EC2 le istanze Amazon. 1. Aggiungere la sottodirectory `recipes` a `createdir-ec2`. ## Configurazione di .kitchen.yml per Amazon EC2 La configurazione viene `.kitchen.yml` effettuata con le informazioni necessarie al `kitchen-ec2` driver per avviare un' EC2 istanza Amazon configurata in modo appropriato. Di seguito è riportato un esempio di `.kitchen.yml` file per un'istanza Amazon Linux nella regione Stati Uniti occidentali (California settentrionale). ``` driver: name: ec2 aws_ssh_key_id: US-East1 region: us-west-1 availability_zone: us-west-1c require_chef_omnibus: true security_group_ids: sg........ subnet_id: subnet-......... associate_public_ip: true interface: dns provisioner: name: chef_solo platforms: -name: amazon driver: image_id: ami-xxxxxxxx transport: username: ec2-user ssh_key: ../ec2_keys/US-East1.pem suites: - name: default run_list: - recipe[createdir-ec2::default] attributes: ``` È possibile utilizzare le impostazioni di default per le sezioni `provisioner` e `suites`, ma vanno modificate le impostazioni predefinite `driver` e `platforms`. Questo esempio utilizza un elenco minimo di impostazioni e accetta i valori di default per il resto. Per un elenco completo delle `kitchen-ec2` impostazioni, consulta [Kitchen: :Ec2: A Test Kitchen Driver per Amazon](https://github.com/test-kitchen/kitchen-ec2). EC2 L'esempio seguente imposta i seguenti attributi `driver`. presupponendo che le chiavi segrete e di accesso dell'utente siano state assegnate alle variabili di ambiente standard, come descritto in precedenza. Il driver utilizza tali chiavi per impostazione predefinita. In alternativa, è necessario specificare le chiavi aggiungendo `aws_access_key_id` e `aws_secret_access_key` agli attributi `driver`, impostati sui valori chiave appropriati. **nome** (Obbligatorio) Questo attributo deve essere impostato su `ec2`. **aws\$1ssh\$1key\$1id** (Obbligatorio) Il nome della coppia di chiavi Amazon EC2 SSH, denominato `US-East1` in questo esempio. **transport.ssh\$1key** (Obbligatorio) Il file della chiave privata (`.pem`) per la chiave specificata per `aws_ssh_key_id`. Per questo esempio, il file è denominato `US-East1.pem` e si trova nella directory `../opsworks/ec2_keys`. **region** (Obbligatorio) La regione AWS dell'istanza. L'esempio utilizza US West (California settentrionale), che è rappresentato da`us-west-1`). **availability\$1zone** (Facoltativo) La zona di disponibilità dell'istanza. Se ometti questa impostazione, Test Kitchen utilizza una zona di disponibilità predefinita per la regione specificata, che corrisponde `us-west-1b` agli Stati Uniti occidentali (California settentrionale). Tuttavia, la zona di default potrebbe non essere disponibile per un determinato account. In tal caso, è necessario specificare una zona di disponibilità. In questa circostanza, l'account utilizzato per preparare gli esempi non supporta `us-west-1b`, per questo l'esempio specifica in modo esplicito `us-west-1c`. **require\$1chef\$1omnibus** Se è impostata su `true`, questa impostazione garantisce che il programma di installazione omnibus venga utilizzato per installare `chef-client` su tutte le istanze della piattaforma. **security\$1group\$1ids** (Facoltativo) Un elenco di gruppi di sicurezza IDs da applicare all'istanza. Questa impostazione applica il gruppo di sicurezza `default` all'istanza. Assicurati che le regole in ingresso del gruppo di sicurezza consentano connessioni SSH, altrimenti Test Kitchen non sarà in grado di comunicare con l'istanza. Se utilizzi il gruppo di sicurezza `default`, potrebbe essere necessario modificarlo di conseguenza. Per ulteriori informazioni, consulta [Amazon EC2 Security Groups](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html). **subnet\$1id** L'ID della sottorete di destinazione per l'istanza, se applicabile. **associate\$1public\$1ip** Puoi fare in modo che Amazon EC2 associ un indirizzo IP pubblico all'istanza se desideri poter accedere all'istanza da Internet. **interface** Il tipo di configurazione del nome host utilizzato per accedere all'istanza. I valori validi sono `dns`, `public`, `private` o `private_dns`. Se non specifichi un valore per questo attributo, `kitchen-ec2` imposta la configurazione del nome host nell'ordine seguente. Se ometti questo attributo, il tipo di configurazione non viene impostato. 1. Nome DNS 1. Indirizzo IP pubblico 1. Indirizzo IP privato 1. Nome DNS privato **Importante** Anziché utilizzare le credenziali del tuo account per le chiavi di accesso e segrete, dovresti creare un utente e fornire tali credenziali a Test Kitchen. Per ulteriori informazioni, consulta [Best practice per la gestione delle chiavi di accesso AWS](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html). Fai attenzione a non inserirlo `.kitchen.yml` in un luogo accessibile al pubblico, ad esempio caricandolo su un repository pubblico GitHub o su Bitbucket. Questo espone le tue credenziali e può compromettere la sicurezza del tuo account. Il driver `kitchen-ec2` fornisce supporto di default per le seguenti piattaforme: + ubuntu-10.04 + ubuntu-12.04 + ubuntu-12.10 + ubuntu-13.04 + ubuntu-13.10 + ubuntu-14.04 + centos-6.4 + debian-7.1.0 + windows-2012r2 + windows-2008r2 Se vuoi utilizzare una o più di queste piattaforme, aggiungi i nomi appropriati a `platforms`. Il driver `kitchen-ec2` seleziona automaticamente un'AMI adeguata e genera un nome utente SSH. Puoi usare altre piattaforme, questo esempio utilizza Amazon Linux, ma devi specificare esplicitamente i seguenti attributi. `platforms` **nome** Il nome della piattaforma. Questo esempio usa Amazon Linux, perciò `name` è impostato su `amazon`. **driver** Gli attributi `driver`, che includono quanto segue: + `image_id`— L'AMI della piattaforma, che deve appartenere alla regione specificata. L'esempio utilizza `ami-ed8e9284` un'AMI Amazon Linux della regione Stati Uniti occidentali (California settentrionale). + `transport.username`— Il nome utente SSH che Test Kitchen utilizzerà per comunicare con l'istanza. Usa `ec2-user` per Amazon Linux. Altri AMIs potrebbero avere nomi utente diversi. Sostituisci il codice in `.kitchen.yml` con l'esempio, quindi assegna valori appropriati agli attributi specifici dell'account, ad esempio `aws_access_key_id`. ## Esecuzione della ricetta In questo esempio viene utilizzata la ricetta contenuta in [Iterazione](cookbooks-101-basics-ruby.md#cookbooks-101-basics-ruby-iteration). **Per eseguire la ricetta** 1. Creare un file denominato `default.rb` con il seguente codice e salvarlo nella cartella `recipes` del libro di ricette. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end ``` 1. Eseguire `kitchen converge` per eseguire la ricetta. Tieni presente che il completamento di questo comando richiederà più tempo rispetto agli esempi precedenti a causa del tempo necessario per avviare e inizializzare un' EC2 istanza Amazon. 1. Vai alla [ EC2console Amazon](https://console.aws.amazon.com/ec2/), seleziona la regione Stati Uniti occidentali (California settentrionale) e fai clic su **Istanze nel riquadro** di navigazione. La nuova istanza sarà visualizzata nell'elenco. 1. Esegui `kitchen login` per accedere all'istanza, proprio come hai fatto per le istanze in esecuzione. VirtualBox Le directory appena create saranno disponibili in `/srv`. È inoltre possibile utilizzare il client SSH preferito per connettersi all'istanza. # Fasi successive **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disabilitato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Questo capitolo ti ha presentato i concetti di base per l'implementazione dei libri di ricette di Chef, ma c'è molto altro: + Gli esempi hanno illustrato come utilizzare alcune delle risorse più comuni, ma ce ne sono molte altre. Per le risorse trattate, gli esempi hanno utilizzato solo alcune delle operazioni e degli attributi disponibili. Per un riferimento completo, consulta la pagina relativa a [risorse e provider](https://docs.chef.io/resource.html). + Negli esempi sono stati utilizzati gli elementi di base dei libri di ricette, ovvero `recipes`, `attributes`, `files` e `templates`. I libri di ricette possono includere anche una serie di altri elementi, ad esempio `libraries`, `definitions` e `specs`. Per ulteriori informazioni, consulta la [documentazione di Chef](https://docs.chef.io). + Negli esempi Test Kitchen è stato utilizzato solo come soluzione pratica per avviare istanze, eseguire ricette e accedere alle istanze. Test Kitchen è principalmente una piattaforma di testing che è possibile utilizzare per eseguire una serie di test sulle ricette. Se non lo hai già fatto, prosegui con la [procedura guidata di Test Kitchen](https://kitchen.ci/docs/getting-started/introduction/), che ti presenterà le caratteristiche di testing. + [Implementazione di Cookbooks for Stacks OpsWorks](cookbooks-101-opsworks.md)fornisce alcuni esempi più avanzati e mostra come implementare i libri di cucina per Stacks. OpsWorks # Implementazione di Cookbooks for Stacks OpsWorks **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). In [Nozioni di base sui libri di ricette](cookbooks-101-basics.md) sono stati introdotti libri di ricette e ricette. Gli esempi in quella sezione erano semplici nella progettazione e funzioneranno su qualsiasi istanza che supporti Chef, comprese le istanze OpsWorks Stacks. Per implementare libri di cucina più sofisticati per OpsWorks Stacks, in genere è necessario sfruttare appieno l'ambiente OpsWorks Stacks, che differisce dallo standard Chef in diversi modi. Questo argomento descrive le basi dell'implementazione delle ricette per le istanze Stacks. OpsWorks **Nota** Se non hai familiarità con le procedure di implementazione dei libri di ricette, ti consigliamo di leggere [Nozioni di base sui libri di ricette](cookbooks-101-basics.md). **Topics** + [Esecuzione di una ricetta su un' OpsWorks istanza Stacks Linux](cookbooks-101-opsworks-opsworks-instance.md) + [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md) + [Esecuzione di uno script di Windows PowerShell](cookbooks-101-opsworks-opsworks-powershell.md) + [Simulazione degli attributi di configurazione e distribuzione dello stack su Vagrant](opsworks-opsworks-mock.md) + [Utilizzo dei valori degli attributi di configurazione e distribuzione dello stack](cookbooks-101-opsworks-opsworks-stack-config.md) + [Utilizzo di un libro di ricette esterno su un'istanza Linux: Berkshelf](cookbooks-101-opsworks-berkshelf.md) + [Utilizzo dell'SDK per Ruby: download di file da Amazon S3](cookbooks-101-opsworks-s3.md) + [Installazione di software Windows](cookbooks-101-opsworks-install-software.md) + [Sostituzione degli attributi integrati](cookbooks-101-opsworks-attributes.md) + [Sostituzione dei modelli integrati](cookbooks-101-opsworks-templates.md) # Esecuzione di una ricetta su un' OpsWorks istanza Stacks Linux **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Test Kitchen e Vagrant forniscono un modo semplice ed efficiente per implementare i libri di cucina, ma per verificare che le ricette di un libro di cucina funzionino correttamente in produzione, devi eseguirle su un'istanza Stacks. OpsWorks In questo argomento viene descritto come installare un libro di ricette personalizzato in un'istanza Linux OpsWorks Stacks ed eseguire una semplice ricetta. L'argomento fornisce inoltre alcuni suggerimenti per correggere in modo efficiente i bug della ricetta. Per informazioni su come eseguire ricette su istanze Windows, consulta [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). **Topics** + [Creazione ed esecuzione della ricetta](#opsworks-opsworks-instance-create) + [Esecuzione automatica della ricetta](#cookbooks-101-opsworks-opsworks-instance-events) + [Risoluzione dei problemi e correzione delle ricette](#cookbooks-101-opsworks-opsworks-instance-bugs) ## Creazione ed esecuzione della ricetta In primo luogo, devi creare uno stack. Di seguito viene brevemente descritto come creare uno stack per questo esempio. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Per creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e fare clic su **Add Stack (Aggiungi stack)**. 1. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e fare clic su **Add Stack (Aggiungi stack)**. + **Nome —** OpsTest + **Chiave SSH predefinita**: una coppia di EC2 chiavi Amazon Se devi creare una coppia di EC2 chiavi Amazon, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). La coppia di chiavi deve appartenere alla stessa regione AWS dell'istanza. L'esempio utilizza la regione predefinita degli Stati Uniti occidentali (Oregon). 1. Fare clic su **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome:** OpsTest + **Nome abbreviato**: opstest Per gli stack Linux sarà appropriato qualunque tipo di livello, tuttavia l'esempio non richiede nessuno dei pacchetti che vengono installati da altri tipi di livello, pertanto un livello personalizzato è l'approccio più semplice. 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello e [avviarla](workinginstances-starting.md). Durante l'avvio dell'istanza, che in genere richiede diversi minuti, puoi creare il ricettario. Questo esempio utilizza una versione leggermente modificata della ricetta da [Logica condizionale](cookbooks-101-basics-ruby.md#cookbooks-101-basics-ruby-conditional), che crea una directory dati il cui nome dipende dalla piattaforma. **Per configurare il libro di ricette** 1. Creare una directory in `opsworks_cookbooks` denominata `opstest` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `opstest`. ``` name "opstest" version "0.1.0" ``` 1. Creare una directory `recipes` in `opstest`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. ``` Chef::Log.info("******Creating a data directory.******") data_dir = value_for_platform( "centos" => { "default" => "/srv/www/shared" }, "ubuntu" => { "default" => "/srv/www/data" }, "default" => "/srv/www/config" ) directory data_dir do mode 0755 owner 'root' group 'root' recursive true action :create end ``` La ricetta registra un messaggio, ma lo fa chiamando `Chef::Log.info`. Non stai usando Test Kitchen per questo esempio, quindi il metodo non è molto utile. `log` `Chef::Log.info`inserisce il messaggio nel registro di Chef, che puoi leggere al termine dell'esecuzione di Chef. OpsWorks Stacks fornisce un modo semplice per visualizzare questi registri, come descritto più avanti. **Nota** I log di Chef in genere contengono una notevole quantità di informazioni di routine, relativamente poco interessanti. I caratteri "\$1" che racchiudono il testo del messaggio ne semplificano l'identificazione. 1. Creare un archivio `.zip` di `opsworks_cookbooks`. Per installare il tuo ricettario su un'istanza di OpsWorks Stacks, devi archiviarlo in un repository e fornire a OpsWorks Stacks le informazioni necessarie per scaricare il ricettario sull'istanza. I libri di ricette possono essere archiviati in uno qualsiasi dei diversi tipi di repository supportati. Questo esempio memorizza un file di archivio contenente i libri di cucina in un bucket Amazon S3. Per ulteriori informazioni sui repository dei libri di ricette, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). **Nota** Per semplicità, questo esempio archivia l'intera directory `opsworks_cookbooks`. Tuttavia, significa che OpsWorks Stacks scaricherà tutti i libri di cucina presenti nell'`opsworks_cookbooks`istanza, anche se ne utilizzerai solo uno. Per installare solo il libro di ricette di esempio, crea un'altra directory padre in cui sposterai `opstest`. Quindi crea un archivio `.zip` della directory padre e utilizzalo al posto di `opsworks_cookbooks.zip`. I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). 1. [Carica l'archivio in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html), [rendilo pubblico](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html) e registra l'URL dell'archivio. Adesso puoi installare il libro di ricette ed eseguire la ricetta. **Per eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository****: S3 Archive** + URL **del repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Utilizzare i valori predefiniti per altre impostazioni e fare clic su **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione corrente dei libri di ricette personalizzati nelle istanze dello stack. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Eseguire la ricetta utilizzando il comando dello stack **Execute Recipes (Esegui ricette)** con **Recipes to execute (Ricette da eseguire)** impostato su **opstest::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito da `opstest::default`. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare opstest** 1. Il primo passaggio consiste nell'esaminare il [log di Chef](troubleshoot-debug-log.md). Fare clic su **show (mostra)** nella colonna **Log (Registro)** dell'istanza opstest1 per visualizzare il registro. Scorrere e visualizzare il messaggio di log verso il basso. ``` ... [2014-07-31T17:01:45+00:00] INFO: Storing updated cookbooks/opsworks_cleanup/attributes/customize.rb in the cache. [2014-07-31T17:01:45+00:00] INFO: Storing updated cookbooks/opsworks_cleanup/metadata.rb in the cache. [2014-07-31T17:01:46+00:00] INFO: ******Creating a data directory.****** [2014-07-31T17:01:46+00:00] INFO: Processing template[/etc/hosts] action create (opsworks_stack_state_sync::hosts line 3) ... ``` 1. [Utilizzare SSH per accedere all'istanza](workinginstances-ssh.md) ed elencare i contenuti di `/srv/www/`. Se hai seguito tutti i passaggi, vedrai `/srv/www/config` piuttosto che la directory `/srv/www/shared` prevista. Nella sezione seguente vengono fornite alcune linee guida per la risoluzione rapida di tali bug. ## Esecuzione automatica della ricetta Il comando **Execute Recipes (Esegui ricette)** è un metodo utile per testare ricette personalizzate. Per tale motivo viene utilizzato nella maggior parte degli esempi. Tuttavia, in pratica di solito esegui le ricette in momenti standard del ciclo di vita di un'istanza, ad esempio dopo il termine dell'avvio dell'istanza o quando distribuisci un'app. OpsWorks Stacks semplifica l'esecuzione di ricette sull'istanza supportando una serie di [eventi del ciclo di vita](workingcookbook-events.md) per ogni livello: Setup, Configure, Deploy, Undeploy e Shutdown. Puoi fare in modo che OpsWorks Stacks esegua automaticamente una ricetta sulle istanze di un layer assegnando la ricetta all'evento del ciclo di vita appropriato. In genere, è opportuno creare le directory non appena terminata la procedura di avvio di un'istanza, che corrisponde all'evento Setup. Di seguito viene mostrato come eseguire la ricetta di esempio al momento dell'installazione, utilizzando lo stesso stack creato in precedenza nell'esempio. Puoi utilizzare la stessa procedura per gli altri eventi. **Per eseguire automaticamente una ricetta al momento della configurazione** 1. **Scegli **Livelli** nel pannello di navigazione, quindi scegli l'icona a forma di matita accanto al link Ricette del OpsTest livello.** 1. Aggiungere **opstest::default** alle ricette **Setup (Installazione)** del livello, fare clic su **\$1** per aggiungerlo al livello e scegliere **Save (Salva)** per salvare la configurazione. 1. Scegliere **Instances (Istanze)**, aggiungere un'altra istanza a un livello e avviarla. L'istanza deve essere denominata `opstest2`. Al termine dell'avvio, OpsWorks Stacks verrà eseguito. `opstest::default` 1. Una volta che l'istanza `opstest2` è online, verificare che `/srv/www/shared` sia presente. **Nota** Se hai assegnato ricette agli eventi Setup, Configure o Deploy, puoi eseguirle anche manualmente utilizzando un [comando dello stack](workingstacks-commands.md) (Setup e Configure) o un [comando di distribuzione](workingapps-deploying.md) (Deploy) per attivare l'evento. Se hai più ricette assegnate a un evento, questi comandi le eseguono tutte. ## Risoluzione dei problemi e correzione delle ricette Se non ottieni i risultati previsti o le tue ricette non vengono eseguite correttamente, il processo di risoluzione dei problemi inizia generalmente con l'esame del log di Chef. Contiene una descrizione dettagliata dell'esecuzione e include eventuali messaggi di log inline delle tue ricette. I log sono particolarmente utili se la tua ricetta semplicemente non riesce. In questo caso, i log di Chef registrano l'errore, inclusa una traccia di stack. Se la ricetta ha esito positivo, come nell'esempio, il log di Chef spesso non si rivela molto utile. In questo caso, puoi individuare il problema solo esaminando più attentamente la ricetta, in particolare le prime righe: ``` Chef::Log.info("******Creating a data directory.******") data_dir = value_for_platform( "centos" => { "default" => "/srv/www/shared" }, "ubuntu" => { "default" => "/srv/www/data" }, "default" => "/srv/www/config" ) ... ``` CentOS è un'alternativa ragionevole per Amazon Linux quando testi ricette su Vagrant, tuttavia attualmente le ricette sono in esecuzione su un'istanza Amazon Linux effettiva. Il valore della piattaforma per Amazon Linux è `amazon`, che non è incluso nella chiamata `value_for_platform`, pertanto la ricetta crea `/srv/www/config` per impostazione predefinita. Per ulteriori informazioni sulla risoluzione dei problemi, consulta [Guida al debugging e alla risoluzione dei problemi](troubleshoot.md). Ora che hai identificato il problema, devi aggiornare la ricetta e verificare la correzione. Puoi tornare ai file sorgente originali, aggiornare`default.rb`, caricare un nuovo archivio su Amazon S3 e così via. Tuttavia, tale processo può risultare lungo e noioso. Di seguito viene mostrato un approccio molto più veloce, particolarmente utile per i bug delle ricette semplici, come quella nell'esempio, che consiste nel modificare la ricetta sull'istanza. **Per modificare una ricetta su un'istanza** 1. Utilizzare SSH per accedere all'istanza ed eseguire `sudo su` per innalzare di livello i privilegi. Per accedere alle directory dei libri di ricette, sono necessari privilegi root. 1. OpsWorks Stacks memorizza il tuo libro di cucina in`/opt/aws/opsworks/current/site-cookbooks`, quindi vai a. `/opt/aws/opsworks/current/site-cookbooks/opstest/recipes` **Nota** OpsWorks Stacks memorizza anche una copia dei tuoi libri di cucina in. `/opt/aws/opsworks/current/merged-cookbooks` Non modificare tale libro di ricette. Quando esegui la ricetta, OpsWorks Stacks copia il ricettario da `.../site-cookbooks` a`.../merged-cookbooks`, quindi tutte le modifiche apportate verranno sovrascritte. `.../merged-cookbooks` 1. Utilizzare un editor di testo sull'istanza per modificare `default.rb` e sostituire `centos` con `amazon`. La ricetta dovrebbe essere simile alla seguente. ``` Chef::Log.info("******Creating a data directory.******") data_dir = value_for_platform( "amazon" => { "default" => "/srv/www/shared" }, "ubuntu" => { "default" => "/srv/www/data" }, "default" => "/srv/www/config" ) ... ``` Per verificare la correzione, esegui la ricetta utilizzando di nuovo il comando dello stack **Execute Recipe (Esegui ricetta)**. L'istanza deve avere una directory `/srv/www/shared`. Se devi apportare ulteriori modifiche a una ricetta, puoi eseguire **Execute Recipe (Esegui ricetta)** in qualsiasi momento. Non è necessario arrestare e riavviare l'istanza a ogni esecuzione del comando. Una volta che la ricetta funzionerà correttamente, non dimenticare di aggiornare il codice nel libro di ricette. **Nota** Se hai assegnato la tua ricetta a un evento del ciclo di vita in modo che OpsWorks Stacks la esegua automaticamente, puoi sempre utilizzare **Execute Recipe per eseguire** nuovamente la ricetta. Puoi anche eseguire nuovamente la ricetta tutte le volte che vuoi senza riavviare l'istanza utilizzando la console Stacks per attivare manualmente l'evento appropriato. OpsWorks Tuttavia, questo approccio esegue tutte le ricette dell'evento. Ecco un promemoria: Utilizza un [comando dello stack](workingstacks-commands.md) per attivare gli eventi Setup o Configure. Utilizza un [comando di distribuzione](workingapps-deploying.md) per attivare gli eventi Deploy o Undeploy. # Esecuzione di una ricetta su un'istanza Windows **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Questo argomento è fondamentalmente una versione abbreviata di [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md), che illustra come eseguire una ricetta su uno stack Windows. Ti consigliamo di consultare prima [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md), perché fornisce una discussione più dettagliata, pertinente in gran parte ai due tipi di sistema operativo. Per una descrizione di come eseguire ricette su istanze OpsWorks Stacks Linux, consulta. [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md) **Topics** + [Abilitazione dell'accesso RDP](#cookbooks-101-opsworks-opsworks-windows-rdp) + [Creazione ed esecuzione della ricetta](#cookbooks-101-opsworks-opsworks-windows-run-recipe) + [Esecuzione automatica della ricetta](#cookbooks-101-opsworks-opsworks-windows-event) ## Abilitazione dell'accesso RDP Prima di iniziare, se non l'hai già fatto, devi configurare un gruppo di sicurezza con una regola in entrata che consente l'accesso RDP per le tue istanze. Tale gruppo sarà necessario al momento della creazione dello stack. Quando crei il primo stack in una regione, OpsWorks Stacks crea un set di gruppi di sicurezza. Ne includono uno chiamato qualcosa del genere`AWS-OpsWorks-RDP-Server`, che OpsWorks Stacks collega a tutte le istanze di Windows per consentire l'accesso RDP. Tuttavia, per impostazione predefinita, questo gruppo di sicurezza non presenta regole, perciò devi aggiungere una regola in entrata per consentire l'accesso RDP alle istanze. **Per consentire l'accesso RDP** 1. Apri la [ EC2console Amazon](https://console.aws.amazon.com/ec2/v2/), impostala sulla regione dello stack e scegli **Security Groups** dal pannello di navigazione. 1. **Scegli **AWS- OpsWorks -RDP-Server**, scegli la scheda **Inbound** e scegli Modifica.** 1. Aggiungere una regola con le impostazioni seguenti: + **Tipo****:** RDP + **Sorgente**: gli indirizzi IP di origine consentiti. In genere vengono permesse richieste RDP in entrata dall'indirizzo IP o da un intervallo di indirizzi IP specificato (di solito l'intervallo di indirizzi IP dell'azienda). **Nota** Come descritto di seguito, devi anche modificare le autorizzazioni utente per consentire l'accesso RDP degli utenti standard. Per ulteriori informazioni, consulta [Accesso con RDP](workinginstances-rdp.md). ## Creazione ed esecuzione della ricetta Di seguito viene brevemente descritto come creare uno stack per questo esempio. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)**. + **Nome:** WindowsRecipeTest + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome** — RecipeTest + **Nome abbreviato**: recipetest 1. [Aggiungi un'istanza 24 ore su 24, 7 giorni su 7](workinginstances-add.md) [con impostazioni predefinite al RecipeTest layer e avviala.](workinginstances-starting.md) OpsWorks Stacks si `AWS-OpsWorks-RDP-Server` assegna automaticamente a questa istanza, il che consente agli utenti autorizzati di accedere all'istanza. 1. Scegliere **Permissions (Autorizzazioni)**, poi **Edit (Modifica)** e **SSH/RDP**, quindi scegliere **sudo/admin**. Gli utenti standard necessitano di questa autorizzazione oltre al gruppo di sicurezza `AWS-OpsWorks-RDP-Server` per accedere all'istanza. **Nota** Puoi anche effettuare l'accesso come amministratore, ma è necessario eseguire una procedura diversa. Per ulteriori informazioni, consulta [Accesso con RDP](workinginstances-rdp.md). Durante l'avvio dell'istanza, che in genere richiede diversi minuti, puoi creare il ricettario. La ricetta di questo esempio crea una directory dati ed è generalmente la ricetta di [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md), modificata per Windows. **Nota** Quando si implementano i libri di cucina per le istanze di OpsWorks Stacks Windows, si utilizza una struttura di directory leggermente diversa da quella utilizzata quando si implementano i libri di cucina per le istanze Stacks Linux. OpsWorks Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). **Per configurare il libro di ricette** 1. Creare una directory denominata `windowstest` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `windowstest`. ``` name "windowstest" version "0.1.0" ``` 1. Creare una directory `recipes` in `windowstest`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. ``` Chef::Log.info("******Creating a data directory.******") directory 'C:\data' do rights :full_control, 'instance_name\username' inherits false action :create end ``` Sostituisci *username* con il tuo nome utente. 1. Inserire il libro di ricette in un repository. Per installare il tuo libro di cucina su un'istanza di OpsWorks Stacks, devi archiviarlo in un repository e fornire a OpsWorks Stacks le informazioni necessarie per scaricare il libro di cucina sull'istanza. Puoi archiviare libri di ricette di Windows come file di archivio in un bucket S3 o in un repository Git. In questo esempio viene utilizzato un bucket S3, perciò è necessario creare un archivio .zip della directory `windowstest`. Per ulteriori informazioni sui repository dei libri di ricette, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). 1. [Caricare l'archivio in un bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html), [rendere pubblico l'archivio](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html) e registrare il relativo URL. È possibile usare anche un archivio privato. Tuttavia, per questo esempio, un archivio pubblico è sufficiente e molto più facile da utilizzare. I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Adesso puoi installare il libro di ricette ed eseguire la ricetta. **Per eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + ****Tipo di repository: S3 Archive**** + URL **del repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione corrente dei libri di ricette personalizzati nelle istanze dello stack, incluse le istanze online. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Dopo aver aggiornato i libri di ricette personalizzati, eseguire la ricetta eseguendo il [comando dello stack **Execute Recipes (Esegui ricette)**](workingstacks-commands.md) con l'opzione **Recipes to execute (Ricette da eseguire)** impostata su **windowstest::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito dalla tua ricetta. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare windowstest** 1. Esaminare il [log di Chef](troubleshoot-debug-log.md). Scegliere **show (mostra)** nella colonna **Log (Registro)** dell'istanza opstest1 per visualizzare il registro. Scorrere e visualizzare il messaggio di log verso il basso. ``` ... [2014-07-31T17:01:45+00:00] INFO: Storing updated cookbooks/opsworks_cleanup/attributes/customize.rb in the cache. [2014-07-31T17:01:45+00:00] INFO: Storing updated cookbooks/opsworks_cleanup/metadata.rb in the cache. [2014-07-31T17:01:46+00:00] INFO: ******Creating a data directory.****** [2014-07-31T17:01:46+00:00] INFO: Processing template[/etc/hosts] action create (opsworks_stack_state_sync::hosts line 3) ... ``` 1. Scegliere **Instances (Istanze)**, quindi **rdp** nella colonna **Actions (Azioni)** dell'istanza e richiedere una password RDP con un periodo di scadenza appropriato. Copiare il nome DNS, il nome utente e la password. È quindi possibile utilizzare tali informazioni con un client RDP, ad esempio il client Windows Remote Desktop Connection, per accedere all'istanza e verificare che `c:\data` esista. Per ulteriori informazioni, consulta [Accesso con RDP](workinginstances-rdp.md). **Nota** Se la tua ricetta non funziona correttamente, consulta [Risoluzione dei problemi e correzione delle ricette](cookbooks-101-opsworks-opsworks-instance.md#cookbooks-101-opsworks-opsworks-instance-bugs) per suggerimenti relativi alla risoluzione dei problemi (la maggior parte di essi si applica anche alle istanze Windows). Se vuoi testare la correzione modificando la ricetta sull'istanza, cerca il tuo ricettario nella `C:\chef\cookbooks` directory, dove OpsWorks Stacks installa i libri di cucina personalizzati. ## Esecuzione automatica della ricetta Il comando **Execute Recipes (Esegui ricette)** è un metodo utile per testare ricette personalizzate. Per tale motivo viene utilizzato nella maggior parte degli esempi. Tuttavia, in pratica di solito esegui le ricette in momenti standard del ciclo di vita di un'istanza, ad esempio dopo il termine dell'avvio dell'istanza o quando distribuisci un'app. OpsWorks Stacks semplifica l'esecuzione di ricette sull'istanza supportando una serie di [eventi del ciclo di vita](workingcookbook-events.md) per ogni livello: Setup, Configure, Deploy, Undeploy e Shutdown. Puoi fare in modo che OpsWorks Stacks esegua automaticamente una ricetta sulle istanze di un layer assegnando la ricetta all'evento del ciclo di vita appropriato. In genere, è opportuno creare le directory non appena terminata la procedura di avvio di un'istanza, che corrisponde all'evento Setup. Di seguito viene mostrato come eseguire la ricetta di esempio al momento dell'installazione, utilizzando lo stesso stack creato in precedenza nell'esempio. Puoi utilizzare la stessa procedura per gli altri eventi. **Per eseguire automaticamente una ricetta al momento della configurazione** 1. **Scegli **Livelli** nel pannello di navigazione, quindi scegli l'icona a forma di matita accanto al link Ricette del RecipeTest livello.** 1. Aggiungere **windowstest::default** alle ricette **Setup (Installazione)** del livello, scegliere **\$1** per aggiungerlo al livello e scegliere **Save (Salva)** per salvare la configurazione. 1. Scegliere **Instances (Istanze)**, aggiungere un'altra istanza a un livello e avviarla. L'istanza deve essere denominata `recipetest2`. Al termine dell'avvio, OpsWorks Stacks verrà eseguito. `windowstest::default` 1. Una volta che l'istanza `recipetest2` è online, verificare che `c:\data` sia presente. **Nota** Se hai assegnato ricette agli eventi Setup, Configure o Deploy, puoi eseguirle anche manualmente utilizzando un [comando dello stack](workingstacks-commands.md) (Setup e Configure) o un [comando di distribuzione](workingapps-deploying.md) (Deploy) per attivare l'evento. Se hai più ricette assegnate a un evento, questi comandi le eseguono tutte. # Esecuzione di uno script di Windows PowerShell **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questi esempi presuppongono che tu abbia già completato l'esempio [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). In caso contrario, ti consigliamo di iniziare da questo esempio, che descrive in particolare come [abilitare l'accesso RDP](cookbooks-101-opsworks-opsworks-windows.md#cookbooks-101-opsworks-opsworks-windows-rdp) alle tue istanze. Un modo per fare in modo che una ricetta esegua attività su un'istanza di Windows, in particolare attività che non dispongono di una risorsa Chef corrispondente, è fare in modo che la ricetta esegua uno script di Windows. PowerShell Questa sezione presenta le nozioni di base descrivendo come utilizzare uno script di Windows per installare una funzionalità di Windows. PowerShell La [https://docs.chef.io/chef/resources.html#powershell-script](https://docs.chef.io/chef/resources.html#powershell-script)risorsa esegue i PowerShell cmdlet di Windows su un'istanza. L'esempio seguente utilizza un [WindowsFeature cmdlet Install-](https://technet.microsoft.com/en-us/library/hh849795.aspx) per installare un visualizzatore XPS sull'istanza. Di seguito viene brevemente descritto come creare uno stack per questo esempio. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e fare clic su **Add Stack (Aggiungi stack)**. + **Nome —** PowerShellTest + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome** — PowerShell + **Nome abbreviato**: powershell 1. [Aggiungi un'istanza 24 ore su 24, 7 giorni su 7](workinginstances-add.md) con le impostazioni predefinite al PowerShell layer e [avviala](workinginstances-starting.md). 1. Scegliere **Permissions (Autorizzazioni)**, poi **Edit (Modifica)** e selezionare **SSH/RDP**, quindi scegliere **sudo/admin**. Per accedere all'istanza come utente standard, è necessario disporre di questa autorizzazione oltre al gruppo di sicurezza `AWS-OpsWorks-RDP-Server`. Durante l'avvio dell'istanza, che in genere richiede diversi minuti, puoi creare il ricettario. La ricetta di questo esempio crea una directory dati ed è generalmente la ricetta di [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md), modificata per Windows. **Per configurare il libro di ricette** 1. Creare una directory denominata `powershell` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `windowstest`. ``` name "powershell" version "0.1.0" ``` 1. Creare una directory `recipes` all'interno della directory `powershell`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. ``` Chef::Log.info("******Installing XPS.******") powershell_script "Install XPS Viewer" do code <<-EOH Install-WindowsFeature XPS-Viewer EOH guard_interpreter :powershell_script not_if "(Get-WindowsFeature -Name XPS-Viewer).installed" end ``` + La risorsa `powershell_script` esegue un cmdlet per installare il visualizzatore XPS. In questo esempio viene eseguito un solo cmdlet, ma il blocco `code` può contenere qualsiasi numero di righe di comando. + L'`guard_interpreter`attributo indica a Chef di utilizzare la versione a 64 bit di Windows. PowerShell + L'attributo di protezione `not_if` fa sì che Chef non installi la funzione se è già stata installata. 1. Creare un archivio `.zip` della directory `powershell`. 1. [Carica l'archivio in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html), [rendilo pubblico](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html) e registra l'URL dell'archivio. È possibile usare anche un archivio privato, tuttavia, per questo esempio, un archivio pubblico è sufficiente e molto più facile da utilizzare. I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Adesso puoi installare il libro di ricette ed eseguire la ricetta. **Per eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository****: S3 Archive** + URL **del repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack **Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)**](workingstacks-commands.md) per installare la versione corrente dei libri di ricette personalizzati nell'istanza. 1. Al termine dell'operazione **Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)**, eseguire la ricetta tramite il [comando dello stack **Execute Recipes (Esegui ricette)**](workingstacks-commands.md) con l'opzione **Recipes to execute (Ricette da eseguire)** impostata su **powershell::default**. **Nota** Questo esempio utilizza **Execute Recipes** per comodità, ma in genere OpsWorks Stacks [esegue le ricette automaticamente](workingcookbook-assigningcustom.md) assegnandole all'evento del ciclo di vita appropriato. Puoi eseguire tali ricette attivando manualmente l'evento e Puoi utilizzare un comando dello stack per attivare gli eventi Setup e Configure e un [comando di distribuzione](workingapps-deploying.md) per attivare gli eventi Deploy e Undeploy. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare la ricetta powershell** 1. Esaminare il [log di Chef](troubleshoot-debug-log.md). Fare clic su **show (mostra)** nella colonna **Log (Registro)** dell'istanza powershell1 per visualizzare il registro. Scorrere e visualizzare il messaggio di log verso il basso. ``` ... [2015-04-27T18:12:09+00:00] INFO: Storing updated cookbooks/powershell/metadata.rb in the cache. [2015-04-27T18:12:09+00:00] INFO: ******Installing XPS.****** [2015-04-27T18:12:09+00:00] INFO: Processing powershell_script[Install XPS Viewer] action run (powershell::default line 3) [2015-04-27T18:12:09+00:00] INFO: Processing powershell_script[Guard resource] action run (dynamically defined) [2015-04-27T18:12:42+00:00] INFO: powershell_script[Install XPS Viewer] ran successfully ... ``` 1. [Utilizzare RDP per accedere all'istanza](workinginstances-rdp.md) e aprire il menu **Start (Avvio)**. Il visualizzatore XPS deve essere elencato con **Windows Accessories (Accessori Windows)**. # Simulazione degli attributi di configurazione e distribuzione dello stack su Vagrant **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo argomento si applica solo alle istanze Linux. Test Kitchen non supporta ancora Windows, quindi eseguirai tutti gli esempi di Windows su OpsWorks istanze Stacks. OpsWorks Stacks aggiunge [gli attributi di configurazione e distribuzione dello stack](workingcookbook-json.md) all'oggetto nodo per ogni istanza dello stack per ogni evento del ciclo di vita. Questi attributi forniscono una snapshot della configurazione dello stack, inclusa la configurazione di ogni livello e le relative istanze online, la configurazione di ogni app distribuita e così via. Poiché questi attributi si trovano nell'oggetto nodo, è possibile accedervi tramite qualsiasi ricetta; la maggior parte delle ricette per le istanze OpsWorks Stacks utilizza uno o più di questi attributi. Un'istanza in esecuzione in una casella Vagrant non è gestita da OpsWorks Stacks, quindi il suo oggetto nodo non include alcun attributo di configurazione e distribuzione dello stack per impostazione predefinita. Tuttavia, puoi aggiungere una serie di attributi idonei all'ambiente Test Kitchen. Test Kitchen aggiunge quindi gli attributi all'oggetto nodo dell'istanza e le tue ricette possono accedere agli attributi proprio come farebbero su un'istanza Stacks. OpsWorks In questo argomento viene illustrato come ottenere una copia degli attributi di configurazione e distribuzione di uno stack idoneo, come installare gli attributi in un'istanza e come accedervi. **Nota** Se utilizzi Test Kitchen per eseguire test sulle tue ricette, [fauxhai](https://github.com/customink/fauxhai) fornisce un metodo alternativo per simulare il JSON di configurazione e distribuzione dello stack. **Per configurare il libro di ricette** 1. Creare una sottodirectory di `opsworks_cookbooks` denominata `printjson` e accedervi. 1. Inizializzare e configurare Test Kitchen, come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md). 1. Aggiungere due sottodirectory a `printjson`: `recipes` ed `environments`. Puoi simulare gli attributi di configurazione e distribuzione dello stack aggiungendo un file di attributi al libro di ricette con le definizioni appropriate, tuttavia un approccio migliore consiste nell'utilizzare l'ambiente Test Kitchen. Sono disponibili due approcci di base: + Aggiungere definizioni degli attributi a `.kitchen.yml`. Questo approccio è particolarmente utile se disponi di alcuni attributi. Per ulteriori informazioni, vedi [kitchen.yml](https://docs.chef.io/config_yml_kitchen.html). + Definire gli attributi in un file di ambiente e fare riferimento al file in `.kitchen.yml`. Questo approccio è generalmente preferibile per gli attributi di configurazione e distribuzione dello stack poiché il file di ambiente è già in formato JSON. Puoi ottenere una copia degli attributi in formato JSON da un'istanza OpsWorks Stacks adatta e incollarla. Tutti gli esempi utilizzano un file di ambiente. Il modo più semplice per creare attributi di configurazione e distribuzione di uno stack per il tuo libro di ricette è realizzare uno stack configurato correttamente e copiare gli attributi risultanti da un'istanza come JSON. Per mantenere il tuo file di ambiente Test Kitchen gestibile, puoi modificare tale JSON in modo da avere solo gli attributi necessari alle tue ricette. Gli esempi in questo capitolo sono basati sullo stack di [Nozioni di base sugli stack Linux Chef 11](gettingstarted.md), ovvero lo stack di un server di applicazioni PHP semplice con sistema di bilanciamento del carico, server di applicazioni PHP e server di database MySQL. **Per creare un JSON di configurazione e distribuzione dello stack** 1. Crea MyStack come descritto in[Nozioni di base sugli stack Linux Chef 11](gettingstarted.md), inclusa la distribuzione di Simple. PHPApp Se preferisci, puoi omettere la seconda istanza di PHP App Server richiesta in[Fase 4: Scalare Out MyStack](gettingstarted-scale.md); gli esempi non utilizzano quegli attributi. 1. Se non è già stato fatto, avviare l'istanza `php-app1`, quindi [accedere con SSH](workinginstances-ssh.md). 1. Nella finestra del terminale, eseguire il seguente comando dell'[interfaccia a riga di comando dell'agente](agent.md): ``` sudo opsworks-agent-cli get_json ``` Questo comando visualizza i più recenti attributi di configurazione e distribuzione dello stack più recente dell'istanza nella finestra del terminale in formato JSON. 1. Copiare il JSON in un file `.json` e salvarlo in una posizione comoda sulla workstation. I dettagli dipendono dal client SSH. Ad esempio, se si sta utilizzando PuTTY su Windows, è possibile eseguire il comando `Copy All to Clipboard`, che copia tutto il testo nella finestra del terminale negli Appunti di Windows. È quindi possibile incollare i contenuti in un file `.json` e modificare il file per rimuovere testo estraneo. 1. Modifica MyStack JSON in base alle esigenze. Gli attributi di configurazione e distribuzione dello stack sono numerosi e i libri di ricette utilizzano generalmente solo una piccola parte di essi. Per mantenere gestibile il file di ambiente, è possibile modificare il JSON in modo che conservi la struttura originale ma contenga solo gli attributi che il libro di ricette effettivamente utilizza. Questo esempio utilizza una versione fortemente modificata di MyStack JSON che include solo due `['opsworks']['stack']` attributi e. `['id]` `['name']` Crea una versione modificata di MyStack JSON simile alla seguente: ``` { "opsworks": { "stack": { "name": "MyStack", "id": "42dfd151-6766-4f1c-9940-ba79e5220b58", }, }, } ``` Per ottenere questo JSON nell'oggetto nodo dell'istanza, è necessario aggiungerlo a un ambiente Test Kitchen. **Per aggiungere gli attributi di configurazione e distribuzione dello stack all'ambiente Test Kitchen** 1. Creare un file di ambiente denominato `test.json` con il seguente contenuto e salvarlo nella cartella `environments` del libro di ricette. ``` { "default_attributes": { "opsworks" : { "stack" : { "name" : "MyStack", "id" : "42dfd151-6766-4f1c-9940-ba79e5220b58" } } }, "chef_type" : "environment", "json_class" : "Chef::Environment" } ``` Il file di ambiente presenta gli elementi seguenti: + `default_attributes`— Gli attributi predefiniti in formato JSON. Questi attributi vengono aggiunti all'oggetto nodo con il tipo di attributo `default`, ovvero il tipo utilizzato da tutti gli attributi JSON di configurazione e distribuzione dello stack. In questo esempio viene utilizzata la versione modificata del JSON di configurazione e distribuzione dello stack illustrata in precedenza. + `chef_type`— Imposta questo elemento su. `environment` + `json_class`— Imposta questo elemento su`Chef::Environment`. 1. Modificare `.kitchen.yml` per definire l'ambiente Test Kitchen, come segue. ``` --- driver: name: vagrant provisioner: name: chef_solo environments_path: ./environments platforms: - name: ubuntu-12.04 suites: - name: printjson provisioner: solo_rb: environment: test run_list: - recipe[printjson::default] attributes: ``` È possibile definire l'ambiente aggiungendo i seguenti elementi al `.kitchen.yml` predefinito creato da `kitchen init`. **provisioner** Aggiungere gli elementi seguenti. + `name`— Imposta questo elemento su`chef_solo`. Per replicare più fedelmente l'ambiente OpsWorks Stacks, puoi utilizzare la [modalità locale del client Chef](https://docs.chef.io/ctl_chef_client.html) anziché Chef solo. La modalità locale è un'opzione del client Chef che utilizza una versione ridotta del server Chef (Chef Zero), eseguita in locale sull'istanza anziché su un server remoto. Questo consente alle ricette di utilizzare funzioni del server Chef, come la ricerca o i contenitori di dati, senza connettersi a un server remoto. + `environments_path`— La sottodirectory cookbook che contiene il file di ambiente, `./environments` per questo esempio. **suites:provisioner** Aggiungi un elemento `solo_rb` con una serie di elementi `environment` al nome del file di ambiente, eliminando l'estensione .json. Questo esempio imposta `environment` su `test`. 1. Creare un file di ricetta denominato `default.rb` con il seguente contenuto e salvarlo nella directory `recipes` del libro di ricette. ``` log "Stack name: #{node['opsworks']['stack']['name']}" log "Stack id: #{node['opsworks']['stack']['id']}" ``` Questa ricetta registra semplicemente i due valori di configurazione e distribuzione dello stack aggiunti all'ambiente. Sebbene la ricetta sia eseguita localmente in Virtual Box, fai riferimento a tali attributi utilizzando la stessa sintassi del nodo che faresti se la ricetta fosse in esecuzione su un' OpsWorks istanza Stacks. 1. Esegui `kitchen converge`. Dovrebbe essere visualizzato un output del log simile al seguente. ``` ... Converging 2 resources Recipe: printjson::default * log[Stack name: MyStack] action write[2014-07-01T23:14:09+00:00] INFO: Processing log[Stack name: MyStack] action write (printjson::default line 1) [2014-07-01T23:14:09+00:00] INFO: Stack name: MyStack * log[Stack id: 42dfd151-6766-4f1c-9940-ba79e5220b58] action write[2014-07-01T23:14:09+00:00] INFO: Processing log[Stack id: 42dfd151-6766-4f1c-9940-ba79e5220b58] action write (printjson::default line 2) [2014-07-01T23:14:09+00:00] INFO: Stack id: 42dfd151-6766-4f1c-9940-ba79e5220b58 ... ``` # Utilizzo dei valori degli attributi di configurazione e distribuzione dello stack **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Le ricette necessitano spesso di informazioni sulla configurazione dello stack o le app distribuite. Ad esempio, potresti avere bisogno di un elenco degli indirizzi IP dello stack per creare un file di configurazione o della directory di distribuzione di un'app per creare una directory di log. Invece di archiviare questi dati su un server centrale, OpsWorks Stacks installa un set di attributi di configurazione e distribuzione dello stack nell'oggetto nodo di ogni istanza per ogni evento del ciclo di vita. Questi attributi rappresentano l'attuale stato dello stack, incluse le app distribuite. Le ricette possono quindi ottenere i dati di cui hanno bisogno dall'oggetto nodo. **Nota** Talvolta le applicazioni necessitano di informazioni dall'oggetto nodo, come i valori degli attributi di configurazione e implementazione dello stack. Tuttavia, un'applicazione non è in grado di accedere all'oggetto nodo. Per fornire i dati dell'oggetto nodo a un'applicazione, puoi implementare una ricetta che recuperi i dati richiesti dall'oggetto nodo e li inserisca in un file in un formato pratico. L'applicazione è quindi in grado di leggere i dati dal file. Per ulteriori informazioni e un esempio, consulta [Passaggio di dati alle applicazioni](apps-data.md). Le ricette possono ottenere i valori degli attributi di configurazione e implementazione dello stack dall'oggetto nodo nel modo seguente. + Direttamente, utilizzando il nome completo di un attributo. Puoi usare questo approccio con qualsiasi stack Linux, ma non con gli stack Windows. + Con la ricerca di Chef, che puoi utilizzare per eseguire query sull'oggetto nodo per i valori degli attributi. Puoi usare questo approccio con gli stack Windows e Chef 11.10, ma non con gli stack Linux. **Nota** Con gli stack Linux, puoi utilizzare l'interfaccia a riga di comando dell'agente per ottenere una copia degli attributi di configurazione e distribuzione dello stack dell'istanza in formato JSON. Per ulteriori informazioni, consulta [Simulazione degli attributi di configurazione e distribuzione dello stack su Vagrant](opsworks-opsworks-mock.md). **Topics** + [Ottenimento diretto dei valori degli attributi](cookbooks-101-opsworks-opsworks-stack-config-node.md) + [Ottenimento dei valori degli attributi con la ricerca di Chef](cookbooks-101-opsworks-opsworks-stack-config-search.md) # Ottenimento diretto dei valori degli attributi **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo approccio funziona solo per gli stack Linux. [Simulazione degli attributi di configurazione e distribuzione dello stack su Vagrant](opsworks-opsworks-mock.md) mostra come ottenere i dati di configurazione e distribuzione dello stack utilizzando la sintassi del nodo per fare riferimento direttamente ad attributi particolari. Questo è talvolta l'approccio migliore. Tuttavia, molti attributi vengono definiti in raccolte o elenchi di cui i contenuti e i nomi possono variare da stack a stack e nel corso del tempo per un determinato stack. Ad esempio, l'attributo `deploy` contiene un elenco di attributi di app denominati con il nome breve dell'app. Questo elenco, che include i nomi degli attributi dell'app, in genere varia da stack a stack e anche da distribuzione a distribuzione. Spesso è quindi più utile, e talvolta anche necessario, ottenere i dati richiesti mediante l'enumerazione degli attributi in un elenco o una raccolta. Ad esempio, supponiamo che desideri conoscere gli indirizzi IP pubblici delle istanze del tuo stack. Questa informazione è nell'attributo `['opsworks']['layers']`, che è impostato su una tabella hash contenente un elemento per ogni livello dello stack, denominato con il nome breve del livello. Ogni elemento del livello è impostato su una tabella hash contenente gli attributi del livello, uno dei quali è `['instances']`. A sua volta, questo elemento è impostato su un'ulteriore tabella hash contenente un attributo per ognuna delle istanze del livello, denominate con il nome breve dell'istanza. Ogni attributo dell'istanza è impostato su ancora un'altra tabella hash che contiene gli attributi dell'istanza, incluso `['ip']`, che rappresenta l'indirizzo IP pubblico. In caso di problemi di visualizzazione, la procedura seguente include un esempio in formato JSON. Questo esempio illustra come ottenere i dati dal JSON di configurazione e distribuzione dello stack per i livelli di uno stack. **Per configurare il libro di ricette** 1. Creare una directory in `opsworks_cookbooks` denominata `listip` e accedervi. 1. Inizializzare e configurare Test Kitchen, come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md). 1. Aggiungere due directory a `listip`: `recipes` ed `environments`. 1. Crea una versione JSON modificata degli attributi di MyStack configurazione e distribuzione che contenga gli attributi pertinenti. Avrà un aspetto simile al seguente. ``` { "opsworks": { "layers": { "php-app": { "name": "PHP App Server", "id": "efd36017-ec42-4423-b655-53e4d3710652", "instances": { "php-app1": { "ip": "192.0.2.0" } } }, "db-master": { "name": "MySQL", "id": "2d8e0b9a-0d29-43b7-8476-a9b2591a7251", "instances": { "db-master1": { "ip": "192.0.2.5" } } }, "lb": { "name": "HAProxy", "id": "d5c4dda9-2888-4b22-b1ea-6d44c7841193", "instances": { "lb1": { "ip": "192.0.2.10" } } } } } } ``` 1. Creare un file di ambiente denominato `test.json`, incollare il JSON di esempio in `default_attributes` e salvare il file nella cartella `environments` del libro di ricette. Il file deve avere un aspetto simile al seguente (per brevità, la maggior parte del JSON di esempio è rappresentato da un'ellissi). ``` { "default_attributes" : { "opsworks": { "layers": { ... } } }, "chef_type" : "environment", "json_class" : "Chef::Environment" } ``` 1. Sostituire il testo in `.kitchen.yml` con il seguente. ``` --- driver: name: vagrant provisioner: name: chef_zero environments_path: ./environment platforms: - name: ubuntu-12.04 suites: - name: listip provisioner: client_rb: environment: test run_list: - recipe[listip::default] attributes: ``` Dopo aver impostato il ricettario, puoi utilizzare la seguente ricetta per registrare il layer. IDs ``` node['opsworks']['layers'].each do |layer, layerdata| log "#{layerdata['name']} : #{layerdata['id']}" end ``` La ricetta enumera i livelli in `['opsworks']['layers']` e registra il nome e l'ID di ogni livello. **Per eseguire la ricetta di registrazione degli ID di livello** 1. Creare un file denominato `default.rb` con la ricetta di esempio e salvarlo nella directory `recipes`. 1. Esegui `kitchen converge`. La parte pertinente dell'output deve essere simile a quanto riportato di seguito. ``` Recipe: listip::default * log[PHP App Server : efd36017-ec42-4423-b655-53e4d3710652] action write[2014-07-17T22:56:19+00:00] INFO: Processing log[PHP App Server : efd36017-ec42-4423-b655-53e4d3710652] action write (listip::default line 4) [2014-07-17T22:56:19+00:00] INFO: PHP App Server : efd36017-ec42-4423-b655-53e4d3710652 * log[MySQL : 2d8e0b9a-0d29-43b7-8476-a9b2591a7251] action write[2014-07-17T22:56:19+00:00] INFO: Processing log[MySQL : 2d8e0b9a-0d29-43b7-8476-a9b2591a7251] action write (listip::default line 4) [2014-07-17T22:56:19+00:00] INFO: MySQL : 2d8e0b9a-0d29-43b7-8476-a9b2591a7251 * log[HAProxy : d5c4dda9-2888-4b22-b1ea-6d44c7841193] action write[2014-07-17T22:56:19+00:00] INFO: Processing log[HAProxy : d5c4dda9-2888-4b22-b1ea-6d44c7841193] action write (listip::default line 4) [2014-07-17T22:56:19+00:00] INFO: HAProxy : d5c4dda9-2888-4b22-b1ea-6d44c7841193 ``` Per visualizzare l'elenco degli indirizzi IP delle istanze, sarà necessario un ciclo nidificato come il seguente. ``` node['opsworks']['layers'].each do |layer, layerdata| log "#{layerdata['name']} : #{layerdata['id']}" layerdata['instances'].each do |instance, instancedata| log "Public IP: #{instancedata['ip']}" end end ``` Il ciclo interno esegue iterazioni sulle istanze di ciascun livello e registra gli indirizzi IP. **Per eseguire la ricetta di registrazione degli IP dell'istanza** 1. Sostituire il codice in `default.rb` con la ricetta di esempio. 1. Eseguire `kitchen converge` per eseguire la ricetta. La parte pertinente dell'output deve essere simile a quanto riportato di seguito. ``` * log[PHP App Server : efd36017-ec42-4423-b655-53e4d3710652] action write[2014-07-17T23:09:34+00:00] INFO: Processing log[PHP App Server : efd36017-ec42-4423-b655-53e4d3710652] action write (listip::default line 2) [2014-07-17T23:09:34+00:00] INFO: PHP App Server : efd36017-ec42-4423-b655-53e4d3710652 * log[Public IP: 192.0.2.0] action write[2014-07-17T23:09:34+00:00] INFO: Processing log[Public IP: 192.0.2.0] action write (listip::default line 4) [2014-07-17T23:09:34+00:00] INFO: Public IP: 192.0.2.0 * log[MySQL : 2d8e0b9a-0d29-43b7-8476-a9b2591a7251] action write[2014-07-17T23:09:34+00:00] INFO: Processing log[MySQL : 2d8e0b9a-0d29-43b7-8476-a9b2591a7251] action write (listip::default line 2) [2014-07-17T23:09:34+00:00] INFO: MySQL : 2d8e0b9a-0d29-43b7-8476-a9b2591a7251 * log[Public IP: 192.0.2.5] action write[2014-07-17T23:09:34+00:00] INFO: Processing log[Public IP: 192.0.2.5] action write (listip::default line 4) [2014-07-17T23:09:34+00:00] INFO: Public IP: 192.0.2.5 * log[HAProxy : d5c4dda9-2888-4b22-b1ea-6d44c7841193] action write[2014-07-17T23:09:34+00:00] INFO: Processing log[HAProxy : d5c4dda9-2888-4b22-b1ea-6d44c7841193] action write (listip::default line 2) [2014-07-17T23:09:34+00:00] INFO: HAProxy : d5c4dda9-2888-4b22-b1ea-6d44c7841193 * log[Public IP: 192.0.2.10] action write[2014-07-17T23:09:34+00:00] INFO: Processing log[Public IP: 192.0.2.10] action write (listip::default line 4) [2014-07-17T23:09:34+00:00] INFO: Public IP: 192.0.2.10 ``` Al termine, eseguire `kitchen destroy`; l'argomento successivo utilizza un nuovo libro di ricette. **Nota** Uno dei motivi più comuni per l'enumerazione di una raccolta JSON di configurazione e distribuzione di uno stack è ottenere i dati di una determinata app distribuita, ad esempio la relativa directory di distribuzione. Per vedere un esempio, consulta [Ricette di ditribuzione](create-custom-deploy.md). # Ottenimento dei valori degli attributi con la ricerca di Chef **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo approccio è disponibile per gli stack Windows e gli stack Linux Chef 11.10. Ottenere i valori degli attributi di configurazione e distribuzione dello stack direttamente dall'oggetto nodo può essere complicato e non è una procedura utilizzabile con gli stack Windows. Un approccio alternativo consiste nell'utilizzare la [ricerca di Chef](http://docs.chef.io/chef_search.html) per eseguire query per gli attributi di interesse. Se conosci il server Chef, scoprirai che Chef search funziona in modo leggermente diverso con OpsWorks Stacks. Poiché OpsWorks Stacks utilizza chef-client in modalità locale, Chef search dipende da una versione locale del server Chef chiamata chef-zero, in modo che la ricerca operi sui dati archiviati localmente nell'oggetto nodo dell'istanza anziché su un server remoto. [In pratica, limitare la ricerca ai dati archiviati localmente di solito non ha importanza perché l'oggetto node su un' OpsWorks istanza Stacks include gli attributi di configurazione e distribuzione dello stack.](workingcookbook-json.md) Contengono la maggior parte se non tutti i dati che le ricette ottengono in genere dal server Chef e utilizzano gli stessi nomi, quindi di solito è possibile utilizzare il codice di ricerca scritto per Chef server su OpsWorks istanze Stacks senza modifiche. Per ulteriori informazioni, consulta [Utilizzo della ricerca di Chef](workingcookbook-chef11-10.md#workingcookbook-chef11-10-search). Di seguito viene mostrata la struttura di base di una query di ricerca: ``` result = search(:search_index, "key:pattern") ``` + L'indice di ricerca specifica gli attributi a cui si applica la query e determina il tipo di oggetto restituito. + La chiave specifica il nome dell'attributo. + Il modello specifica i valori dell'attributo che intendi recuperare. Puoi eseguire query per valori di attributi specifici oppure utilizzare i caratteri jolly per eseguire query per un'ampia gamma di valori. + Il risultato è un elenco di oggetti che soddisfano la query. Ciascuno di questi è una tabella hash contenente più attributi correlati. Ad esempio, se utilizzi l'indice di ricerca `node`, la query restituisce un elenco di oggetti istanza, uno per ogni istanza che soddisfa la query. Ogni oggetto è una tabella hash che contiene un set di attributi che definiscono la configurazione dell'istanza, ad esempio il nome host e l'indirizzo IP. Ad esempio, la query seguente utilizza l'indice di ricerca `node`, ovvero un indice Chef standard che si applica alle istanze dello stack (o nodi, nella terminologia Chef). Questo consente di cercare le istanze con nome host `myhost`. ``` result = search(:node, "hostname:myhost") ``` La ricerca restituisce un elenco di oggetti istanza il cui nome host è `myhost`. Il sistema operativo della prima istanza, ad esempio, sarà rappresentato da `result[0][:os]`. Se la query restituisce più oggetti, puoi enumerarli per recuperare le informazioni richieste. I dettagli relativi a come utilizzare la ricerca in una ricetta variano a seconda che tu stia utilizzando uno stack Linux o Windows. I seguenti argomenti forniscono esempi in merito a entrambi i tipi di stack. **Topics** + [Utilizzo della ricerca su uno stack Linux](cookbooks-101-opsworks-opsworks-stack-config-search-linux.md) + [Utilizzo della ricerca su uno stack Windows](cookbooks-101-opsworks-opsworks-stack-config-search-windows.md) # Utilizzo della ricerca su uno stack Linux **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Questo esempio si basa su uno stack Linux con un unico server di applicazioni PHP. Utilizza la ricerca di Chef per ottenere l'indirizzo IP pubblico del server e inserisce l'indirizzo in un file nella directory `/tmp`. Recupera essenzialmente le stesse informazioni dall'oggetto nodo di [Ottenimento diretto dei valori degli attributi](cookbooks-101-opsworks-opsworks-stack-config-node.md), ma il codice è molto più semplice e non dipende dai dettagli della struttura degli attributi di configurazione e distribuzione dello stack. Di seguito viene brevemente descritto come creare lo stack per questo esempio. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Nota** Se non hai mai eseguito una ricetta personalizzata su un'istanza OpsWorks Stacks, dovresti prima seguire l'esempio. [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md) **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e fare clic su **Add Stack (Aggiungi stack)**. 1. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e fare clic su **Add Stack (Aggiungi stack)**. + **Nome: searchJSON** + **Chiave SSH predefinita**: una coppia di EC2 chiavi Amazon Se devi creare una coppia di EC2 chiavi Amazon, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). La coppia di chiavi deve appartenere alla stessa regione AWS dell'istanza. L'esempio utilizza la regione Stati Uniti occidentali (Oregon). 1. Fai clic su **Aggiungi un livello** e [aggiungi un livello PHP App Server allo](workinglayers-custom.md) stack con le impostazioni predefinite. 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello e [avviarla](workinginstances-starting.md). **Per configurare il libro di ricette** 1. Creare una directory in `opsworks_cookbooks` denominata `searchjson` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `opstest`. ``` name "searchjson" version "0.1.0" ``` 1. Creare una directory `recipes` in `searchjson`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. ``` phpserver = search(:node, "layers:php-app").first Chef::Log.info("**********The public IP address is: '#{phpserver[:ip]}'**********") file "/tmp/ip_addresses" do content "#{phpserver[:ip]}" mode 0644 action :create end ``` Gli stack Linux supportano solo l'indice di ricerca `node`. La ricetta utilizza questo indice per ottenere un elenco di istanze nel livello `php-app`. Poiché il livello è noto per avere una sola istanza, la ricetta assegna semplicemente la prima a `phpserver`. Se il livello ha più istanze, puoi enumerarle per recuperare le informazioni richieste. Ogni voce dell'elenco è una tabella hash contenente un set di attributi di istanza. L'attributo `ip` è impostato sull'indirizzo IP pubblico dell'istanza, pertanto puoi rappresentare tale indirizzo nel codice della ricetta successiva nella forma `phpserver[:ip]`. Dopo aver aggiunto un messaggio al log di Chef, la ricetta usa una risorsa [https://docs.chef.io/chef/resources.html#file](https://docs.chef.io/chef/resources.html#file) per creare un file denominato `ip_addresses`. L'attributo `content` è impostato su una rappresentazione di stringa di `phpserver[:ip]`. Quando Chef crea `ip_addresses`, aggiunge la stringa al file. 1. Crea un `.zip` archivio di`opsworks_cookbooks`, [carica l'archivio in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html), [rendi l'archivio pubblico](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html) e registra l'URL dell'archivio. Per ulteriori informazioni sui repository dei libri di ricette, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Adesso puoi installare il libro di ricette ed eseguire la ricetta. **Per eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository****: Http Archive** + URL del **repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Utilizzare i valori predefiniti per altre impostazioni e fare clic su **Save (Salva)** per aggiornare la configurazione dello stack. 1. Modifica la configurazione personalizzata del livello e [assegnala `searchjson::default` all'evento Setup](workingcookbook-assigningcustom.md) del livello. OpsWorks Stacks eseguirà la ricetta dopo l'avvio dell'istanza o se attivi esplicitamente l'evento Setup. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione corrente del repository dei libri di ricette personalizzati nelle istanze dello stack. Se è presente una versione precedente del repository, verrà sovrascritta da questo comando. 1. Eseguire la ricetta utilizzando il comando dello stack **Setup (Installazione)**, che attiva un evento Setup sull'istanza ed esegue `searchjson::default`. Lasciare aperta la pagina **Running command setup (Esecuzione configurazione comando)**. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare searchjson** 1. Il primo passo è esaminare il [log di Chef](troubleshoot-debug-log.md) per l'evento Setup più recente. Nella **pagina di configurazione dell'esecuzione del comando**, fare clic su **show (mostra)** nella colonna **Log** dell'istanza php-app1 per visualizzare il log. Scorrere verso il basso per trovare il messaggio di log verso la metà. Sarà simile al seguente. ``` ... [2014-09-05T17:08:41+00:00] WARN: Previous bash[logdir_existence_and_restart_apache2]: ... [2014-09-05T17:08:41+00:00] WARN: Current bash[logdir_existence_and_restart_apache2]: ... [2014-09-05T17:08:41+00:00] INFO: **********The public IP address is: '192.0.2.0'********** [2014-09-05T17:08:41+00:00] INFO: Processing directory[/etc/sysctl.d] action create (opsworks_initial_setup::sysctl line 1) ... ``` 1. [Utilizzare SSH per accedere all'istanza](workinginstances-ssh.md) ed elencare i contenuti di `/tmp`, che dovrebbero includere un file denominato `ip_addresses` contenente l'indirizzo IP. # Utilizzo della ricerca su uno stack Windows **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disabilitato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). OpsWorks Stacks offre due opzioni per utilizzare la ricerca negli stack di Windows. + L'indice di ricerca `node`, che può essere utilizzato per eseguire query su un set di attributi standard di Chef. Se disponi di ricette esistenti con il codice di ricerca che utilizza`node`, di solito funzionano sugli OpsWorks stack di Stacks senza modifiche. + È possibile utilizzare un ulteriore set di indici di ricerca per eseguire query su set di attributi di OpsWorks Stacks specifici e alcuni attributi standard. Questi indici vengono illustrati in [Utilizzo di indici di ricerca OpsWorks specifici per Stacks su Windows Stacks](cookbooks-101-opsworks-opsworks-stack-config-search-opsworks.md). Ti consigliamo di usare `node` per recuperare informazioni standard, come nomi host o indirizzi IP. Questo approccio manterrà la tue ricette conformi alle pratiche standard di Chef. Usa gli indici di ricerca di OpsWorks Stacks per recuperare informazioni specifiche di Stacks. OpsWorks **Topics** + [Utilizzo dell'indice di ricerca del nodo sugli stack Windows](cookbooks-101-opsworks-opsworks-stack-config-search-node.md) + [Utilizzo di indici di ricerca OpsWorks specifici per Stacks su Windows Stacks](cookbooks-101-opsworks-opsworks-stack-config-search-opsworks.md) # Utilizzo dell'indice di ricerca del nodo sugli stack Windows **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo esempio presuppone che tu abbia già completato l'esempio [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). In caso contrario, ti consigliamo di iniziare da questo esempio, che descrive in particolare come abilitare l'accesso RDP alle istanze. Questo esempio si basa su uno stack Windows con un singolo livello personalizzato e un'istanza. Uilizza la ricerca di Chef con l'indice di ricerca `node` per ottenere l'indirizzo IP pubblico del server e inserisce l'indirizzo in un file nella directory `C:\tmp`. Di seguito viene brevemente descritto come creare lo stack per questo esempio. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. 1. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)**. + **Nome —** NodeSearch + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome** — IPTest + **Nome breve**: iptest 1. [Aggiungi un'istanza t2.micro 24 ore su 24, 7 giorni su 7](workinginstances-add.md) [con impostazioni predefinite al IPTest layer e avviala.](workinginstances-starting.md) Verrà denominata iptest1. OpsWorks Stacks si `AWS-OpsWorks-RDP-Server` assegna automaticamente a questa istanza, il che consente agli utenti autorizzati di accedere all'istanza. 1. Scegliere **Permissions (Autorizzazioni)**, poi **Edit (Modifica)** e selezionare **SSH/RDP**, quindi scegliere **sudo/admin**. Gli utenti standard necessitano di questa autorizzazione oltre al gruppo di sicurezza `AWS-OpsWorks-RDP-Server` per accedere all'istanza. **Nota** Puoi anche effettuare l'accesso come amministratore, ma è necessario eseguire una procedura diversa. Per ulteriori informazioni, consulta [Accesso con RDP](workinginstances-rdp.md). **Per configurare il libro di ricette** 1. Creare una directory denominata `nodesearch` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `opstest`. ``` name "nodesearch" version "0.1.0" ``` 1. Creare una directory `recipes` in `nodesearch`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. ``` directory 'C:\tmp' do rights :full_control, 'Everyone' recursive true action :create end windowsserver = search(:node, "hostname:iptest*").first Chef::Log.info("**********The public IP address is: '#{windowsserver[:ipaddress]}'**********") file 'C:\tmp\addresses.txt' do content "#{windowsserver[:ipaddress]}" rights :full_control, 'Everyone' action :create end ``` La ricetta effettua le seguenti operazioni: 1. Utilizza una risorsa di directory per creare una directory `C:\tmp` per il file. Per ulteriori informazioni su questa risorsa, consulta [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md). 1. Utilizza la ricerca di Chef con l'indice di ricerca `node` per ottenere un elenco di nodi (istanze) con un nome host che inizia per `iptest`. Se si utilizza il tema predefinito, che crea nomi host aggiungendo numeri interi al nome breve del layer, questa query restituirà ogni istanza del layer. IPTest In questo esempio il livello ha una sola istanza, pertanto la ricetta assegna semplicemente la prima a `windowsserver`. Per più istanze, puoi ottenere un elenco completo, quindi puoi enumerarle. 1. Aggiunge un messaggio con l'indirizzo IP del log di Chef per questa esecuzione. L'oggetto `windowsserver` è una tabella hash il cui attributo `ipaddress` è impostato sull'indirizzo IP pubblico dell'istanza, pertanto puoi rappresentare tale indirizzo nel codice della ricetta successiva nella forma `windowsserver[:ipaddress]`. La ricetta inserisce la stringa corrispondente nel messaggio e la aggiunge al log di Chef. 1. Utilizza la risorsa `file` per creare un file con l'indirizzo IP denominato `C:\tmp\addresses.txt`. L'attributo `content` della risorsa specifica contenuto da aggiungere al file, ovvero, in questo caso, l'indirizzo IP pubblico. 1. Creare un archivio `.zip` di `nodesearch`, [Caricare l'archivio in un bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html), [rendere pubblico l'archivio](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html) e registrare il relativo URL. I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Adesso puoi installare il libro di ricette ed eseguire la ricetta. **Per installare il libro di ricette ed eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di **repository**: S3 Archive** + URL **del repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione corrente dei libri di ricette personalizzati nelle istanze dello stack, incluse le istanze online. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Al termine dell'operazione Update Custom Cookbooks (Aggiorna libri di ricette personalizzati), eseguire la ricetta tramite il [comando dello stack **Execute Recipes (Esegui ricette)**](workingstacks-commands.md) con l'opzione **Recipes to execute (Ricette da eseguire)** impostata su **nodesearch::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito dalla tua ricetta. Lasciare la pagina execute\$1recipes aperta. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare nodesearch** 1. Esaminare il [log di Chef](troubleshoot-debug-log.md) per l'evento execute\$1recipes più recente. Nella **pagina di esecuzione del comando execute\$1recipes**, scegliere **show (mostra)** nella colonna **Log** dell'istanza iptest1 per visualizzare il log. Scorrere verso il basso per trovare il messaggio di log, che sarà simile al seguente. ``` ... [2015-05-13T18:55:47+00:00] INFO: Storing updated cookbooks/nodesearch/recipes/default.rb in the cache. [2015-05-13T18:55:47+00:00] INFO: Storing updated cookbooks/nodesearch/metadata.rb in the cache. [2015-05-13T18:55:47+00:00] INFO: **********The public IP address is: '192.0.0.1'********** [2015-05-13T18:55:47+00:00] INFO: Processing directory[C:\tmp] action create (nodesearch::default line 1) [2015-05-13T18:55:47+00:00] INFO: Processing file[C:\tmp\addresses.txt] action create (nodesearch::default line 10) ... ``` 1. [Utilizzare RDP per accedere all'istanza](workinginstances-rdp.md) ed esaminare i contenuti di `C:\tmp\addresses.txt`. # Utilizzo di indici di ricerca OpsWorks specifici per Stacks su Windows Stacks **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo esempio presuppone che tu abbia già completato l'esempio [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). In caso contrario, ti consigliamo di iniziare da questo esempio, che descrive in particolare come abilitare l'accesso RDP alle istanze. OpsWorks Stacks fornisce i seguenti indici di ricerca oltre a: `node` + `aws_opsworks_stack`— La configurazione dello stack. + `aws_opsworks_layer`— Le configurazioni dei livelli dello stack. + `aws_opsworks_instance`— Le configurazioni delle istanze dello stack. + `aws_opsworks_app`— Le configurazioni delle app dello stack. + `aws_opsworks_user`— Le configurazioni utente dello stack. + `aws_opsworks_rds_db_instance`— Informazioni di connessione per le istanze RDS registrate. Questi indici includono alcuni attributi Chef standard, ma sono destinati principalmente al recupero di attributi specifici di Stacks. OpsWorks Ad esempio `aws_opsworks_instance` include un attributo `status` che fornisce lo stato dell'istanza, come `online`. **Nota** La procedura consigliata consiste nell'utilizzare `node` quando possibile per mantenere le ricette conformi all'utilizzo standard di Chef. Per vedere un esempio, consulta [Utilizzo dell'indice di ricerca del nodo sugli stack Windows](cookbooks-101-opsworks-opsworks-stack-config-search-node.md). Questo esempio mostra come utilizzare gli indici Stacks per recuperare il valore di un attributo specifico di OpsWorks Stacks. OpsWorks Si basa su uno stack Windows semplice con un livello personalizzato che include un'istanza. Utilizza la ricerca Chef per ottenere l'ID OpsWorks Stacks dell'istanza e inserisce i risultati nel registro Chef. Di seguito viene brevemente descritto come creare uno stack per questo esempio. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **\$1 Stack**. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)**. + **Nome:** IDSearch + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome** — IDCheck + **Nome abbreviato**: idcheck 1. [Aggiungi un'istanza t2.micro 24 ore su 24, 7 giorni su 7](workinginstances-add.md) [con impostazioni predefinite al IDCheck livello e avviala.](workinginstances-starting.md) Verrà denominata iptest1. OpsWorks Stacks si `AWS-OpsWorks-RDP-Server` assegna automaticamente a questa istanza. [Abilitazione dell'accesso RDP](cookbooks-101-opsworks-opsworks-windows.md#cookbooks-101-opsworks-opsworks-windows-rdp)spiega come aggiungere una regola in entrata a questo gruppo di sicurezza che consenta agli utenti autorizzati di accedere all'istanza. 1. Scegliere **Permissions (Autorizzazioni)**, poi **Edit (Modifica)** e **SSH/RDP**, quindi scegliere **sudo/admin**. Gli utenti standard necessitano di questa autorizzazione oltre al gruppo di sicurezza `AWS-OpsWorks-RDP-Server` per accedere all'istanza. **Nota** Puoi anche effettuare l'accesso come amministratore, ma è necessario eseguire una procedura diversa. Per ulteriori informazioni, consulta [Accesso con RDP](workinginstances-rdp.md). **Per configurare il libro di ricette** 1. Creare una directory denominata `idcheck` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `opstest`. ``` name "idcheck" version "0.1.0" ``` 1. Creare una directory `recipes` in `idcheck` e aggiungere un file `default.rb` alla directory che contiene la seguente ricetta. ``` windowsserver = search(:aws_opsworks_instance, "hostname:idcheck*").first Chef::Log.info("**********The public IP address is: '#{windowsserver[:instance_id]}'**********") ``` La ricetta usa la ricerca di Chef con un indice di ricerca `aws_opsworks_instance` per ottenere gli [attributi di istanza](data-bag-json-instance.md) di ciascuna istanza nello stack con un nome host che inizia per `idcheck`. Se si utilizza il tema predefinito, che crea nomi host aggiungendo numeri interi al nome breve del layer, questa query restituirà ogni istanza del layer. IDCheck In questo esempio il livello ha una sola istanza, pertanto la ricetta assegna semplicemente la prima a `windowsserver`. Per più istanze, puoi ottenere un elenco completo, quindi puoi enumerarle. La ricetta sfrutta il fatto che esiste una sola istanza nello stack con questo nome host, pertanto il primo risultato è quello corretto. Se il tuo stack dispone di più istanze, la ricerca su altri attributi può restituire più di un risultato. Per un elenco di attributi di istanza, consulta [Contenitore di dati dell'istanza (aws\$1opsworks\$1instance)](data-bag-json-instance.md). Gli attributi dell'istanza sono fondamentalmente una tabella hash e all'`instance_id`attributo viene assegnato OpsWorks lo Stacks ID dell'istanza, quindi potete fare riferimento all'ID come. `windowsserver[:instance_id]` La ricetta inserisce la stringa corrispondente nel messaggio e la aggiunge al log di Chef. 1. Crea un `.zip` archivio del `ipaddress` libro di cucina, [carica l'archivio in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html) e registra l'URL dell'archivio. Per ulteriori informazioni sui repository dei libri di ricette, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Adesso puoi installare il libro di ricette ed eseguire la ricetta. **Per installare il libro di ricette ed eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di **repository**: S3 Archive** + URL **del repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione corrente dei libri di ricette personalizzati nelle istanze dello stack, incluse le istanze online. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Dopo aver aggiornato i libri di ricette personalizzati, eseguire la ricetta eseguendo il [comando dello stack **Execute Recipes (Esegui ricette)**](workingstacks-commands.md) con l'opzione **Recipes to execute (Ricette da eseguire)** impostata su **idcheck::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito dalla tua ricetta. Lasciare la pagina execute\$1recipes aperta. Dopo che la ricetta è stata eseguita correttamente, è possibile verificarla esaminando il [log di Chef](troubleshoot-debug-log.md) per l'evento execute\$1recipes più recente. Nella **pagina di esecuzione del comando execute\$1recipes**, scegliere **show (mostra)** nella colonna **Log** dell'istanza iptest1 per visualizzare il log. Scorrere verso il basso per trovare il messaggio di log, che sarà simile al seguente. ``` ... [2015-05-13T20:03:47+00:00] INFO: Storing updated cookbooks/nodesearch/recipes/default.rb in the cache. [2015-05-13T20:03:47+00:00] INFO: Storing updated cookbooks/nodesearch/metadata.rb in the cache. [2015-05-13T20:03:47+00:00] INFO: **********The instance ID is: 'i-8703b570'********** [2015-05-13T20:03:47+00:00] INFO: Chef Run complete in 0.312518 seconds ... ``` # Utilizzo di un libro di ricette esterno su un'istanza Linux: Berkshelf **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Berkshelf è disponibile solo per gli stack Linux Chef 11.10. Prima di avviare l'implementazione di un libro di ricette, consulta la pagina relativa ai [libri di ricette della community](https://github.com/opscode-cookbooks), che contiene i libri di ricette creati dai membri della community Chef per un'ampia gamma di scopi. Molti di questi libri di cucina possono essere utilizzati con OpsWorks Stacks senza modifiche, quindi potresti sfruttarli per alcune delle tue attività invece di implementare tutto il codice da solo. Per usare un libro di ricette esterno su un'istanza, devi installarlo e gestire eventuali dipendenze. L'approccio preferito consiste nell'implementare un libro di ricette che supporta un gestore delle dipendenze denominato Berkshelf. Berkshelf funziona su istanze Amazon, incluse EC2 le istanze OpsWorks Stacks, ma è anche progettato per funzionare con Test Kitchen e Vagrant. Tuttavia, l'utilizzo su Vagrant è leggermente diverso rispetto a OpsWorks Stacks, quindi questo argomento include esempi per entrambe le piattaforme. Per ulteriori informazioni su come usare Berkshelf, consulta [Berkshelf](http://berkshelf.com/). **Topics** + [Utilizzo di Berkshelf con Test Kitchen e Vagrant](#cookbooks-101-opsworks-berkshelf-vagrant) + [Usare Berkshelf con Stacks OpsWorks](#opsworks-berkshelf-opsworks) ## Utilizzo di Berkshelf con Test Kitchen e Vagrant Questo esempio illustra come utilizzare Berkshelf per installare il libro di ricette della community getting-started ed eseguirne la ricetta, che consente di installare un breve file di testo nella tua directory principale sull'istanza. **Per installare Berkshelf e inizializzare un libro di ricette** 1. Installare il pacchetto Berkshelf nella workstation, come descritto di seguito. ``` gem install berkshelf ``` A seconda della workstation, questo comando può richiedere `sudo` oppure è possibile anche utilizzare un gestore di ambiente Ruby come [RVM](https://rvm.io/). Per verificare che Berkshelf sia stato installato correttamente, eseguire `berks --version`. 1. Il libro di ricette per questo argomento è denominato external\$1cookbook. È possibile utilizzare Berkshelf per creare un libro di ricette inizializzato anziché ricorrere all'approccio manuale degli argomenti precedenti. Per farlo, accedere alla directory `opsworks_cookbooks` ed eseguire il comando seguente. ``` berks cookbook external_cookbook ``` Il comando crea la directory `external_cookbook` e diverse sottodirectory standard di Chef e Test Kitchen, incluse `recipes` e `test`. Inoltre, crea versioni predefinite di numerosi file standard, inclusi i seguenti: + `metadata.rb` + I file di configurazione per Vagrant, Test Kitchen e Berkshelf + Una ricetta `default.rb` vuota nella directory `recipes` **Nota** Non è necessario eseguire `kitchen init`, il comando `berks cookbook` gestisce tali attività. 1. Esegui `kitchen converge`. Il libro di ricette appena creato non fa niente di interessante per il momento, ma converge. **Nota** Inoltre puoi usare `berks init` per inizializzare un libro di ricette esistente al fine di utilizzare Berkshelf. Per usare Berkshelf allo scopo di gestire le dipendenze esterne di un libro di ricette, la directory radice del libro di ricette deve contenere un `Berksfile`, ovvero un file di configurazione che specifica come Berkshelf dovrebbe gestire le dipendenze. Quando hai utilizzato `berks cookbook` per creare il libro di ricette `external_cookbook`, è stato creato un `Berksfile` con i seguenti contenuti. ``` source "https://supermarket.chef.io" metadata ``` Il file include le dichiarazioni seguenti: + `source`— L'URL di una fonte di libri di cucina. Un Berksfile può avere un qualsiasi numero di dichiarazioni `source`, ciascuna delle quali specifica un'origine predefinita per i libri di ricette dipendenti. Se non specifichi esplicitamente un'origine del libro di ricette, Berkshelf cerca nei repository predefiniti un libro di ricette con lo stesso nome. Il Berksfile predefinito include un singolo attributo `source` che specifica il repository del libro di ricette della community. Questo repository contiene il libro di ricette getting-started, che ti consente di lasciare la riga invariata. + `metadata`— Indica a Berkshelf di includere le dipendenze dei libri di cucina dichiarate nel file del libro di cucina. `metadata.rb` Inoltre puoi dichiarare un libro di ricette dipendente nel Berksfile includendo un attributo `cookbook`, come illustrato in seguito. Esistono due modi per dichiarare una dipendenza del libro di ricette: + Includendo una dichiarazione `cookbook` nel Berksfile. Questo è l'approccio usato da Stacks. OpsWorks Ad esempio per specificare il libro di ricette getting-started utilizzato in questo esempio, includi `cookbook "getting-started"` nel Berksfile. Berkshelf cercherà quindi nei repository predefiniti un libro di ricette con tale nome. Puoi inoltre utilizzare `cookbook` per specificare in modo esplicito un'origine del libro di ricette, nonché una determinata versione. Per ulteriori informazioni, consulta [Berkshelf](http://berkshelf.com/). + Includendo una dichiarazione `metadata` nel Berksfile e dichiarando la dipendenza in `metadata.rb`. Questa dichiarazione indica a Berkshelf di includere le dipendenze del libro di ricette dichiarate in `metadata.rb`. Ad esempio, per dichiarare una dipendenza getting-started, aggiungere una dichiarazione `depends 'getting-started'` al file `metadata.rb` del libro di ricette. Questo esempio utilizza il primo approccio, per garantire la coerenza con OpsWorks Stacks. **Per installare il libro di ricette getting-started** 1. Modificare il Berksfile predefinito per sostituire la dichiarazione `metadata` con una dichiarazione `cookbook` per `getting-started`. I contenuti devono essere simili ai seguenti. ``` source "https://supermarket.chef.io" cookbook 'getting-started' ``` 1. Eseguire `berks install`, che scarica il libro di ricette getting-started dal repository del libro di ricette della community alla directory Berkshelf della workstation, generalmente `~/.berkshelf`. Spesso questa directory si chiama semplicemente *il Berkshelf*. Cercare nella directory `cookbooks` del Berkshelf la directory per il libro di ricette getting-started, che avrà un nome simile a `getting-started-0.4.0`. 1. Sostituire `external_cookbook::default` nell'elenco di esecuzione `.kitchen.yml` con `getting-started::default`. In questo esempio non viene eseguita alcuna ricetta da external\$1cookbook. È fondamentalmente solo un modo per utilizzare il libro di ricette getting-started. Adesso il file `.kitchen.yml` avrà un aspetto simile al seguente. ``` --- driver: name: vagrant provisioner: name: chef_solo platforms: - name: ubuntu-12.04 suites: - name: default run_list: - recipe[getting-started::default] attributes: ``` 1. Eseguire `kitchen converge` e utilizzare `kitchen login` per accedere all'istanza. La directory di accesso deve contenere un file denominato `chef-getting-started.txt` con elementi simili ai seguenti: ``` Welcome to Chef! This is Chef version 11.12.8. Running on ubuntu. Version 12.04. ``` Test Kitchen installa libri di ricette nella directory `/tmp/kitchen/cookbooks` dell'istanza. Se si elencano i contenuti di tale directory, verranno visualizzati due libri di ricette: external\$1cookbook e getting-started. 1. Eseguire `kitchen destroy` per arrestare l'istanza. L'esempio successivo utilizza un' OpsWorks istanza Stacks. ## Usare Berkshelf con Stacks OpsWorks OpsWorks Stacks supporta opzionalmente gli stack Berkshelf for Chef 11.10. Per usare Berkshelf con il tuo stack, devi procedere come descritto di seguito. + Abilita Berkshelf per lo stack. OpsWorks Stacks gestisce quindi i dettagli dell'installazione di Berkshelf sulle istanze dello stack. + Aggiungi un Berksfile alla directory radice del repository del libro di ricette. Il Berksfile deve contenere le dichiarazioni `source` e `cookbook` per tutti i libri di ricette dipendenti. Quando OpsWorks Stacks installa il tuo repository di libri di cucina personalizzato su un'istanza, utilizza Berkshelf per installare i libri di cucina dipendenti dichiarati nel Berksfile del repository. Per ulteriori informazioni, consulta [Utilizzo di Berkshelf](workingcookbook-chef11-10.md#workingcookbook-chef11-10-berkshelf). Questo esempio mostra come utilizzare Berkshelf per installare il ricettario della community per iniziare su un'istanza Stacks. OpsWorks Inoltre, installa una versione del libro di ricette personalizzato createfile, che crea un file in una directory specificata. Per ulteriori informazioni sul funzionamento di createfile, consulta [Installazione di un file da un libro di ricette](cookbooks-101-basics-files.md#cookbooks-101-basics-files-cookbook_file). **Nota** Se è la prima volta che installi un ricettario personalizzato su uno OpsWorks stack Stacks, dovresti prima seguire l'esempio. [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md) Inizia creando uno stack, come descritto brevemente di seguito. Per ulteriori informazioni, consulta [Creare un nuovo stack](workingstacks-creating.md). **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e fare clic su **Add Stack (Aggiungi stack)**. 1. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e fare clic su **Add Stack (Aggiungi stack)**. + **Nome —** BerksTest + **Chiave SSH predefinita**: una coppia di EC2 chiavi Amazon Se devi creare una coppia di EC2 chiavi Amazon, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). La coppia di chiavi deve appartenere alla stessa regione AWS dell'istanza. L'esempio utilizza la regione predefinita degli Stati Uniti occidentali (Oregon). 1. Fare clic su **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome:** BerksTest + **Nome abbreviato**: berkstest Puoi effettivamente usare qualsiasi tipo di livello per questo esempio. Tuttavia, l'esempio non richiede nessuno dei pacchetti che vengono installati da altri tipi di livelli, pertanto un livello personalizzato è l'approccio più semplice. 1. [Aggiungi un'istanza 24 ore su 24, 7 giorni su 7](workinginstances-add.md) al BerksTest layer con le impostazioni predefinite, ma non avviarla ancora. Con OpsWorks Stacks, i libri di cucina devono trovarsi in un archivio remoto con una struttura di directory standard. Quindi fornisci le informazioni di download a OpsWorks Stacks, che scarica automaticamente il repository su ciascuna istanza dello stack all'avvio. Per semplicità, il repository di questo esempio è un archivio Amazon S3 pubblico, OpsWorks ma Stacks supporta anche archivi HTTP, repository Git e repository Subversion. Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). **Per creare il repository del libro di ricette** 1. Nella directory `opsworks_cookbooks` creare una directory denominata `berkstest_cookbooks`. Se lo si preferisce, è possibile creare questa directory ovunque si ritiene che possa essere utile, perché verrà caricata in un repository. 1. Aggiungere un file denominato Berksfile a `berkstest_cookbooks` con i contenuti seguenti. ``` source "https://supermarket.chef.io" cookbook 'getting-started' ``` Questo file dichiara la dipendenza del libro di ricette getting-started e indica a Berkshelf di scaricarlo dal sito del libro di ricette della community. 1. Aggiungere una directory `createfile` a `berkstest_cookbooks` contenente quanto segue. + Un file `metadata.rb` con i seguenti contenuti. ``` name "createfile" version "0.1.0" ``` + Una directory `files/default` con un file `example_data.json` che include il contenuto seguente. ``` { "my_name" : "myname", "your_name" : "yourname", "a_number" : 42, "a_boolean" : true } ``` Il nome e il contenuto del file sono arbitrari. La ricetta semplicemente copia il file nel percorso specificato. + Una directory `recipes` contenente un file `default.rb` con il codice ricetta seguente. ``` directory "/srv/www/shared" do mode 0755 owner 'root' group 'root' recursive true action :create end cookbook_file "/srv/www/shared/example_data.json" do source "example_data.json" mode 0644 action :create_if_missing end ``` Questa ricetta crea `/srv/www/shared` e copia `example_data.json` in tale directory dalla directory `files` del libro di ricette. 1. Crea un `.zip` archivio di`berkstest_cookbooks`, [carica l'archivio in un bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/UG/UploadingObjectsintoAmazonS3.html), [rendi l'archivio pubblico](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html) e registra l'URL dell'archivio. Adesso puoi installare i libri di ricette ed eseguire la ricetta. **Per installare i libri di ricette ed eseguire le ricette** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository****: Http Archive** + URL del **repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza + **Gestisci Berkshelf** **— Sì** Le prime due impostazioni forniscono a OpsWorks Stacks le informazioni necessarie per scaricare l'archivio dei libri di cucina nelle tue istanze. L'ultima impostazione abilita il supporto di Berkshelf, che scarica il libro di ricette getting-started nell'istanza. Accettare i valori predefiniti per altre impostazioni e fare clic su **Save (Salva)** per aggiornare la configurazione dello stack. 1. Modifica il BerksTest layer per [aggiungere le seguenti ricette all'evento Setup lifecycle del layer](workingcookbook-assigningcustom.md). + `getting-started::default` + `createfile::default` 1. [Avviare](workinginstances-starting.md) l'istanza. L'evento Setup si verifica al termine dell'avvio dell'istanza. OpsWorks Stacks installa quindi il repository di libri di cucina, utilizza Berkshelf per scaricare il ricettario introduttivo ed esegue la configurazione del layer e distribuisce le ricette, tra cui and. `getting-started::default` `createfile::default` 1. Una volta che l'istanza è online, [utilizzare SSH per accedere](workinginstances-ssh.md). Verrà visualizzato un codice analogo al seguente + `/srv/www/shared` deve contenere `example_data.json`. + `/root` deve contenere `chef-getting-started.txt`. OpsWorks Stacks esegue le ricette come root, quindi Getting-Started installa il file nella directory anziché nella directory home. `/root` # Utilizzo dell'SDK per Ruby: download di file da Amazon S3 **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Alcune attività, come l'interazione con i servizi AWS, non possono essere gestite con le risorse Chef. Ad esempio, talvolta è preferibile archiviare file in remoto e scaricarli nell'istanza per mezzo di una ricetta. Puoi utilizzare la risorsa [remote\$1file](https://docs.chef.io/chef/resources.html#remote-file) per scaricare file dai server remoti. Tuttavia, se desideri archiviare i tuoi file in un [bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html), `remote_file` puoi scaricarli solo se l'[ACL consente l'operazione](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html). Le ricette possono utilizzare l'[AWS SDK per Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/) per accedere alla maggior parte dei servizi AWS. Questo argomento mostra come utilizzare l'SDK for Ruby per scaricare un file da un bucket S3. **Nota** Per ulteriori informazioni su come utilizzare l'[AWS SDK per Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/) per gestire la crittografia e la decrittografia, consulta [AWS::S3::S3Object](https://docs.aws.amazon.com/AWSRubySDK/latest/AWS/S3/S3Object.html). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). **Topics** + [Utilizzo dell'SDK per Ruby su un'istanza Vagrant](cookbooks-101-opsworks-s3-vagrant.md) + [Utilizzo dell'SDK for Ruby OpsWorks su un'istanza Stacks Linux](cookbooks-101-opsworks-s3-opsworks.md) + [Utilizzo dell'SDK for Ruby OpsWorks su un'istanza Stacks Windows](cookbooks-101-opsworks-s3-windows.md) # Utilizzo dell'SDK per Ruby su un'istanza Vagrant **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disabilitato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Questo argomento descrive come una ricetta in esecuzione su un'istanza Vagrant può utilizzare [AWS SDK per Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/)per scaricare un file da Amazon S3. Prima di iniziare, devi prima disporre di un set di AWS credenziali, una chiave di accesso e una chiave di accesso segreta, che consentano alla ricetta di accedere ad Amazon S3. **Importante** Ti consigliamo di non utilizzare credenziali dell'account root a questo scopo. Invece, crea un utente con una politica appropriata e fornisci quelle credenziali alla ricetta. Fai attenzione a non inserire le credenziali, nemmeno le credenziali degli utenti IAM, in una posizione accessibile al pubblico, ad esempio caricando un file contenente le credenziali in un repository pubblico o Bitbucket. GitHub Questo espone le tue credenziali e può compromettere la sicurezza del tuo account. Le ricette eseguite su un' EC2 istanza EC2 Amazon possono utilizzare un approccio ancora migliore, un ruolo IAM, come descritto in[Utilizzo dell'SDK for Ruby OpsWorks su un'istanza Stacks Linux](cookbooks-101-opsworks-s3-opsworks.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Se non disponi già di un utente appropriato, puoi crearne uno nel modo seguente. Per ulteriori informazioni, consulta [Cos'è IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/Introduction.html). **avvertimento** Gli utenti IAM dispongono di credenziali a lungo termine, il che rappresenta un rischio per la sicurezza. Per ridurre questo rischio, si consiglia di fornire a questi utenti solo le autorizzazioni necessarie per eseguire l'attività e di rimuoverli quando non sono più necessari. **Per creare un utente IAM** 1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Nel riquadro di navigazione, scegli **Utenti** e, se necessario, scegli **Aggiungi utenti** per creare un nuovo utente amministrativo. 1. Nella pagina **Imposta autorizzazioni**, scegli **Allega direttamente le politiche**. 1. Digita **S3** nella casella **di ricerca Politiche di autorizzazione** per visualizzare le politiche di Amazon S3. **Scegli AmazonS3. ReadOnlyAccess** Se preferisci, puoi specificare una politica che conceda autorizzazioni più ampie, come **AmazonS3 FullAccess**, ma la prassi standard prevede di concedere solo le autorizzazioni necessarie. In questo caso, la ricetta non farà che scaricare un file, pertanto un accesso in sola lettura è sufficiente. 1. Scegli **Next (Successivo)**. 1. Scegli **Crea utente**. 1. Quindi crea le chiavi di accesso per il tuo utente. Per ulteriori informazioni sulla creazione di chiavi di accesso, consulta [Gestione delle chiavi di accesso per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) nella *Guida per l'utente di IAM*. A questo punto, devi fornire un file da scaricare. Questo esempio presuppone che inserirai un file denominato `myfile.txt` in un nuovo bucket S3 chiamato `cookbook_bucket`. **Per fornire un file per il download** 1. Creare un file denominato `myfile.txt` con il testo seguente e salvarlo in una posizione comoda sulla workstation. ``` This is the file that you just downloaded from Amazon S3. ``` 1. Sulla [console Amazon S3](https://console.aws.amazon.com/s3/), crea un bucket denominato `cookbook_bucket` nella regione **Standard** e caricalo `myfile.txt` nel bucket. Configurare il libro di ricette come segue. **Per configurare il libro di ricette** 1. Creare una directory in `opsworks_cookbooks` denominata `s3bucket` e accedervi. 1. Inizializzare e configurare Test Kitchen, come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md). 1. Sostituire il testo in `.kitchen.yml` con il seguente. ``` --- driver: name: vagrant provisioner: name: chef_solo environments_path: ./environments platforms: - name: ubuntu-14.04 suites: - name: s3bucket provisioner: solo_rb: environment: test run_list: - recipe[s3bucket::default] attributes: ``` 1. Aggiungere due directory a `s3bucket`: `recipes` ed `environments`. 1. Crea un file di ambiente denominato `test.json` `default_attributes` nella sezione seguente, sostituendo `secret_key` i valori `access_key` and con le chiavi corrispondenti per il tuo utente. Salvare il file nella cartella `environments` del libro di ricette. ``` { "default_attributes" : { "cookbooks_101" : { "access_key": "AKIAIOSFODNN7EXAMPLE", "secret_key" : "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" } }, "chef_type" : "environment", "json_class" : "Chef::Environment" } ``` Hai a disposizione diversi metodi per fornire le credenziali a una ricetta in esecuzione su un'istanza. Il concetto fondamentale è limitare le possibilità di esporre accidentalmente le chiavi e compromettere la sicurezza del tuo account. Per questo motivo, non è consigliabile utilizzare valori chiave espliciti nel tuo codice. L'esempio invece colloca i valori chiave nell'oggetto nodo, che consente alla ricetta di farvi riferimento utilizzando la sintassi del nodo anziché esponendo valori letterali. Devi disporre di privilegi root per accedere all'oggetto nodo, che limita le possibilità che le chiavi possano essere esposte. Per ulteriori informazioni, consulta [Best practice per la gestione delle chiavi di accesso AWS](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html). **Nota** L'esempio utilizza gli attributi nidificati, con `cookbooks_101` come primo elemento. Questa pratica limita la possibilità di un conflitto di nomi se vi sono altri attributi `access_key` o `secret_key` nell'oggetto nodo. La ricetta seguente scarica `myfile.text` dal bucket `cookbook_bucket`. ``` gem_package "aws-sdk ~> 3" do action :install end ruby_block "download-object" do block do require 'aws-sdk' s3 = Aws::S3::Client.new( :access_key_id => "#{node['cookbooks_101']['access_key']}", :secret_access_key => "#{node['cookbooks_101']['secret_key']}") myfile = s3.bucket['cookbook_bucket'].objects['myfile.txt'] Dir.chdir("/tmp") File.open("myfile.txt", "w") do |f| f.write(myfile.read) f.close end end action :run end ``` La prima parte della ricetta installa l'SDK for Ruby, che è un pacchetto gem. La risorsa [gem\$1package](https://docs.chef.io/chef/resources.html#gem-package) installa gem che verranno utilizzati da ricette o altre applicazioni. **Nota** Di norma la tua istanza ha due istanze di Ruby, che sono generalmente versioni diverse. Una è un'istanza dedicata che viene utilizzata dal client Chef. L'altra viene utilizzato da applicazioni e ricette in esecuzione sull'istanza. È importante comprendere questa distinzione quando si installano pacchetti gem, perché per installare gem sono disponibili due risorse, [gem\$1package](https://docs.chef.io/chef/resources.html#gem-package) e [chef\$1gem](https://docs.chef.io/chef/resources.html#chef-gem). Se le applicazioni o le ricette utilizzano il pacchetto gem, installarlo con `gem_package`. `chef_gem` è solo per i pacchetti gem utilizzati dal client Chef. Il resto della ricetta è una risorsa [ruby\$1block](https://docs.chef.io/chef/resources.html#ruby-block), contenente il codice Ruby che scarica il file. Potresti pensare che, poiché una ricetta è un'applicazione Ruby, puoi inserire il codice direttamente nella ricetta. Tuttavia, un'esecuzione di Chef compila tutto questo codice prima dell'esecuzione di qualunque risorsa. Se inserisci il codice di esempio direttamente nella ricetta, Ruby cercherà di risolvere l'istruzione `require 'aws-sdk'` prima di eseguire la risorsa `gem_package`. Poiché l'SDK for Ruby non è ancora stato installato, la compilazione avrà esito negativo. Il codice in una risorsa `ruby_block` non viene compilato finché tale risorsa non viene eseguita. In questo esempio, la `ruby_block` risorsa viene eseguita dopo che la `gem_package` risorsa ha terminato l'installazione dell'SDK for Ruby, quindi il codice verrà eseguito correttamente. Il codice in `ruby_block` funziona come segue. 1. Crea un nuovo oggetto [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3.html](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3.html), che fornisce l'interfaccia di servizio. Le chiavi segrete e di accesso vengono specificate facendo riferimento ai valori memorizzati nell'oggetto nodo. 1. Chiama l'associazione `bucket.objects` dell'oggetto `S3`, che restituisce un oggetto [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html) denominato `myfile` che rappresenta `myfile.txt`. 1. Utilizza `Dir.chdir` per impostare la directory di lavoro su `/tmp`. 1. Apre un file denominato `myfile.txt`, scrive i contenuti di `myfile` nel file e chiude il file. **Per eseguire la ricetta** 1. Creare un file denominato `default.rb` con la ricetta di esempio e salvarlo nella directory `recipes`. 1. Esegui `kitchen converge`. 1. Eseguire `kitchen login` per accedere all'istanza, quindi eseguire `ls /tmp`. Dovrebbe essere possibile vedere `myfile.txt`, insieme a diversi file e directory di Test Kitchen. ``` vagrant@s3bucket-ubuntu-1204:~$ ls /tmp install.sh kitchen myfile.txt stderr ``` È inoltre possibile eseguire `cat /tmp/myfile.txt` per verificare che il contenuto del file sia corretto. Al termine dell'operazione, eseguire `kitchen destroy` per terminare l'istanza. # Utilizzo dell'SDK for Ruby OpsWorks su un'istanza Stacks Linux **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Questo argomento descrive come utilizzare l'SDK for Ruby OpsWorks su un'istanza Stacks Linux per scaricare un file da un bucket Amazon S3. OpsWorks Stacks installa automaticamente l'SDK for Ruby su ogni istanza Linux. Tuttavia, al momento della creazione di un oggetto client del servizio, devi fornire un set di credenziali di AWS idoneo `AWS::S3.new` o l'equivalente per altri servizi. I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). [Utilizzo dell'SDK per Ruby su un'istanza Vagrant](cookbooks-101-opsworks-s3-vagrant.md) mostra come mitigare il rischio di esposizione delle tue credenziali archiviando le credenziali nell'oggetto nodo e facendo riferimento agli attributi nel codice della tua ricetta. Quando esegui ricette su un' EC2istanza Amazon, hai un'opzione ancora migliore, un [ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html). Un ruolo IAM funziona in modo molto simile a un utente IAM. Ha una policy collegata che concede autorizzazioni per l'utilizzo di vari servizi AWS. Tuttavia, assegni un ruolo a un' EC2istanza Amazon anziché a un individuo. Le applicazioni in esecuzione su tale istanza possono quindi acquisire le autorizzazioni concesse dalla policy collegata. Con un ruolo, le credenziali non compaiono mai nel codice, neanche indirettamente. Questo argomento descrive come utilizzare un ruolo IAM per eseguire la ricetta da [Utilizzo dell'SDK per Ruby su un'istanza Vagrant](cookbooks-101-opsworks-s3-vagrant.md) un' EC2 istanza Amazon. Puoi eseguire questa ricetta con Test Kitchen utilizzando il driver kitchen-ec2, come descritto in [Esempio 9: utilizzo di Amazon EC2 Instances](cookbooks-101-basics-ec2.md). Tuttavia, l'installazione dell'SDK for Ruby EC2 sulle istanze Amazon è piuttosto complicata e non è qualcosa di cui devi preoccuparti per Stacks. OpsWorks Tutte le istanze OpsWorks Stacks Linux hanno l'SDK for Ruby installato per impostazione predefinita. Per semplicità, l'esempio utilizza quindi un'istanza Stacks. OpsWorks Il primo passaggio consiste nell'impostare il ruolo IAM. Questo esempio utilizza l'approccio più semplice, che consiste nell'utilizzare il EC2 ruolo Amazon creato da OpsWorks Stacks quando crei il primo stack. È denominato `aws-opsworks-ec2-role`. Tuttavia, OpsWorks Stacks non assegna una policy a quel ruolo, quindi per impostazione predefinita non concede autorizzazioni. È necessario allegare la `AmazonS3ReadOnlyAccess` politica al `aws-opsworks-ec2-role` ruolo per concedere le autorizzazioni appropriate. Per ulteriori informazioni su come allegare una policy a un ruolo, consulta [Adding IAM identity permissions (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella *IAM* User Guide. Specifica il ruolo durante la creazione o l'aggiornamento di uno stack. Configura uno stack con un livello personalizzato, come descritto in [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md), con un'aggiunta. **Nella pagina **Add Stack**, verifica che il **profilo predefinito dell'istanza IAM** sia impostato su 2 ruoli. aws-opsworks-ec** OpsWorks Stacks assegnerà quindi quel ruolo a tutte le istanze dello stack. La procedura per la configurazione del libro di ricette è simile a quella utilizzata da [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md). Di seguito è riportato un breve riepilogo. Per i dettagli, fai riferimento a tale esempio. **Per configurare il libro di ricette** 1. Creare una directory denominata `s3bucket_ops` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `s3bucket_ops`. ``` name "s3bucket_ops" version "0.1.0" ``` 1. Creare una directory `recipes` in `s3bucket_ops`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. ``` Chef::Log.info("******Downloading a file from Amazon S3.******") ruby_block "download-object" do block do require 'aws-sdk' s3 = AWS::S3.new myfile = s3.buckets['cookbook_bucket'].objects['myfile.txt'] Dir.chdir("/tmp") File.open("myfile.txt", "w") do |f| f.syswrite(myfile.read) f.close end end action :run end ``` 1. Crea un `.zip` archivio di `s3bucket_ops` e caricalo in un bucket Amazon S3. Per semplicità, [rendere pubblico l'archivio](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html), quindi registrare l'URL dell'archivio per utilizzarlo in futuro. Puoi anche archiviare i tuoi libri di cucina in un archivio privato di Amazon S3 o in diversi altri tipi di repository. Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). Questa ricetta è simile a quella utilizzata dall'esempio precedente, con le seguenti eccezioni. + Poiché OpsWorks Stacks ha già installato l'SDK for Ruby, la risorsa è stata `chef_gem` eliminata. + La ricetta non passa credenziali ad `AWS::S3.new`. Le credenziali sono assegnate automaticamente all'applicazione in base al ruolo dell'istanza. + La ricetta impiega `Chef::Log.info` per aggiungere un messaggio al log di Chef. Crea uno stack per questo esempio nel modo seguente. Puoi anche utilizzare uno stack Windows esistente. È sufficiente aggiornare i libri di ricette, come descritto di seguito. **Per creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e fare clic su **Add Stack (Aggiungi stack)**. 1. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e fare clic su **Add Stack (Aggiungi stack)**. + **Nome: RubySDK** + **Chiave SSH predefinita**: una coppia di EC2 chiavi Amazon Se devi creare una coppia di EC2 chiavi Amazon, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). La coppia di chiavi deve appartenere alla stessa regione AWS dell'istanza. L'esempio utilizza la regione predefinita degli Stati Uniti occidentali (Oregon). 1. Fare clic su **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome:** S3Download + **Nome breve**: s3download Per gli stack Linux sarà appropriato qualunque tipo di livello, tuttavia l'esempio non richiede nessuno dei pacchetti che vengono installati da altri tipi di livello, pertanto un livello personalizzato è l'approccio più semplice. 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello e [avviarla](workinginstances-starting.md). Ora puoi installare ed eseguire la ricetta **Per eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository****: Http Archive** + URL del **repository: l'URL** di archivio del libro di cucina che hai registrato in precedenza. Utilizzare i valori predefiniti per altre impostazioni e fare clic su **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione corrente dei libri di ricette personalizzati nelle istanze dello stack. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Eseguire la ricetta utilizzando il comando dello stack **Execute Recipes (Esegui ricette)** con **Recipes to execute (Ricette da eseguire)** impostato su **s3bucket\$1ops::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito da `s3bucket_ops::default`. **Nota** In genere, fai in modo che OpsWorks Stacks [esegua le tue ricette automaticamente](workingcookbook-assigningcustom.md) assegnandole all'evento del ciclo di vita appropriato. Puoi eseguire tali ricette attivando manualmente l'evento e Puoi utilizzare un comando dello stack per attivare gli eventi Setup e Configure e un [comando di distribuzione](workingapps-deploying.md) per attivare gli eventi Deploy e Undeploy. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare s3bucket\$1ops** 1. Il primo passaggio consiste nell'esaminare il log di Chef. Lo stack deve disporre di un'istanza denominata opstest1. Nella pagina **Instances (Istanze)** fare clic su **show (mostra)** nella colonna **Log** dell'istanza per visualizzare il log di Chef. Scorrere verso il basso per trovare il messaggio di log. ``` ... [2014-07-31T17:01:45+00:00] INFO: Storing updated cookbooks/opsworks_cleanup/attributes/customize.rb in the cache. [2014-07-31T17:01:45+00:00] INFO: Storing updated cookbooks/opsworks_cleanup/metadata.rb in the cache. [2014-07-31T17:01:46+00:00] INFO: ******Downloading a file from Amazon S3.****** [2014-07-31T17:01:46+00:00] INFO: Processing template[/etc/hosts] action create (opsworks_stack_state_sync::hosts line 3) ... ``` 1. [Utilizzare SSH per accedere all'istanza](workinginstances-ssh.md) ed elencare i contenuti di `/tmp`. # Utilizzo dell'SDK for Ruby OpsWorks su un'istanza Stacks Windows **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo esempio presuppone che tu abbia già completato l'esempio [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). In caso contrario, ti consigliamo di iniziare da questo esempio, che descrive in particolare come abilitare l'accesso RDP alle istanze. I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Questo argomento descrive come utilizzare [AWS SDK per Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/)su un'istanza Windows OpsWorks Stacks per scaricare un file da un bucket S3. Se un'applicazione Ruby ha l'esigenza di accedere a una risorsa AWS, devi fornirle un set di credenziali di AWS con le autorizzazioni appropriate. Per le ricette, l'opzione migliore per fornire le credenziali AWS è utilizzare un [ruolo AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html). Un ruolo IAM funziona in modo molto simile a un utente IAM: ha una policy allegata che concede le autorizzazioni per utilizzare i vari servizi. AWS Tuttavia, assegni un ruolo a un'istanza Amazon Elastic Compute Cloud EC2 (Amazon) anziché a un individuo. Le applicazioni in esecuzione su tale istanza possono quindi acquisire le autorizzazioni concesse dalla policy collegata. Con un ruolo, le credenziali non compaiono mai nel codice, neanche indirettamente. Il primo passo è configurare il ruolo IAM. Questo esempio utilizza l'approccio più semplice, che consiste nell'utilizzare il EC2 ruolo Amazon creato da OpsWorks Stacks quando crei il primo stack. È denominato `aws-opsworks-ec2-role`. Tuttavia, OpsWorks Stacks non assegna una policy a quel ruolo, quindi per impostazione predefinita non concede autorizzazioni. È necessario allegare la `AmazonS3ReadOnlyAccess` politica al `aws-opsworks-ec2-role` ruolo per concedere le autorizzazioni appropriate. Per ulteriori informazioni su come allegare una policy a un ruolo, consulta [Adding IAM identity permissions (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella *IAM* User Guide. Specifica il ruolo durante la creazione o l'aggiornamento di uno stack. Configura uno stack con un livello personalizzato, come descritto in [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md), con un'aggiunta. **Nella pagina **Add Stack**, verifica che il **profilo predefinito dell'istanza IAM** sia impostato su 2 ruoli. aws-opsworks-ec** OpsWorks Stacks assegnerà quindi quel ruolo a tutte le istanze dello stack. La procedura per la configurazione del libro di ricette è simile a quella utilizzata da [Esecuzione di una ricetta su un'istanza Linux](cookbooks-101-opsworks-opsworks-instance.md). Di seguito è riportato un breve riepilogo. Per i dettagli, fai riferimento a tale esempio. **Per configurare il libro di ricette** 1. Creare una directory denominata `s3bucket_ops` e accedervi. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo in `s3bucket_ops`. ``` name "s3download" version "0.1.0" ``` 1. Creare una directory `recipes` in `s3download`. 1. Creare un file `default.rb` con la seguente ricetta e salvarlo nella directory `recipes`. Sostituiscilo *windows-cookbooks* con il nome del bucket S3 che utilizzerai per archiviare il file da scaricare. ``` Chef::Log.info("******Downloading an object from S3******") chef_gem "aws-sdk-s3" do compile_time false action :install end ruby_block "download-object" do block do require 'aws-sdk-s3' Aws.use_bundled_cert! s3_client = Aws::S3::Client.new(region:'us-west-2') s3_client.get_object(bucket: 'windows-cookbooks', key: 'myfile.txt', response_target: '/chef/myfile.txt') end action :run end ``` 1. Creare un archivio `.zip` di `s3download` e caricare il file in un bucket S3. Rendere il file pubblico e registrare l'URL per utilizzarlo successivamente. 1. Creare un file di testo denominato `myfile.txt` e caricarlo in un bucket S3. Questo è il file che verrà scaricato dalla ricetta, perciò è possibile usare qualsiasi bucket comodo. La ricetta esegue le seguenti attività. 1: Installa l'SDK per Ruby v2. L'esempio utilizza l'SDK for Ruby per scaricare l'oggetto. Tuttavia, OpsWorks Stacks non installa questo SDK su istanze Windows, quindi la prima parte della ricetta utilizza una [https://docs.chef.io/chef/resources.html#chef-gem](https://docs.chef.io/chef/resources.html#chef-gem)risorsa per gestire tale attività. Questa risorsa viene utilizzata per installare gem per l'utilizzo da parte di Chef, che include ricette. 2: Scarica il file. La terza parte della ricetta utilizza una [https://docs.chef.io/chef/resources.html#ruby-block](https://docs.chef.io/chef/resources.html#ruby-block)risorsa per eseguire il codice SDK for Ruby v2 da `myfile.txt` scaricare da un `windows-cookbooks` bucket S3 denominato nella directory dell'istanza. `/chef` Sostituisci `windows-cookbooks` con il nome del bucket che contiene `myfile.txt`. **Nota** Una ricetta è un'applicazione Ruby, pertanto puoi inserire il codice Ruby nel corpo della ricetta. Tale codice non deve trovarsi in una risorsa `ruby_block`. Tuttavia, Chef esegue prima il codice Ruby nel corpo della ricetta, quindi ciascuna risorsa, nell'ordine. Per questo esempio, se inserisci il codice di download nel corpo della ricetta, fallirà perché dipende dall'SDK for Ruby `chef_gem` e la risorsa che installa l'SDK non è ancora stata eseguita. Il codice nella `ruby_block` risorsa viene eseguito quando viene eseguita la risorsa e ciò avviene dopo che la `chef_gem` risorsa ha installato l'SDK for Ruby. Crea uno stack per questo esempio nel modo seguente. Puoi anche utilizzare uno stack Windows esistente. È sufficiente aggiornare i libri di ricette, come descritto di seguito. **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)**. + **Nome: S3Download** + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome:** S3Download + **Nome breve**: s3download 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello S3Download e [avviarla](workinginstances-starting.md). Ora puoi installare ed eseguire la ricetta **Per eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository****: S3 Archive.** + URL del **repository: l'URL** di archivio del libro di cucina che hai registrato in precedenza. Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)](workingstacks-commands.md), che installa la versione più recente del libro di ricette personalizzato nelle istanze online dello stack. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Eseguire la ricetta utilizzando il comando dello stack **Execute Recipes (Esegui ricette)** con **Recipes to execute (Ricette da eseguire)** impostato su **s3download::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito da `s3download::default`. **Nota** In genere, fai in modo che OpsWorks Stacks [esegua le tue ricette automaticamente](workingcookbook-assigningcustom.md) assegnandole all'evento del ciclo di vita appropriato. Puoi anche eseguire tali ricette attivando manualmente l'evento. Puoi utilizzare un comando dello stack per attivare gli eventi Setup e Configure e un [comando di distribuzione](workingapps-deploying.md) per attivare gli eventi Deploy e Undeploy. Dopo aver eseguito correttamente la ricetta, puoi verificarla. **Per verificare s3download** 1. Il primo passaggio consiste nell'esaminare il log di Chef. Lo stack deve disporre di un'istanza denominata s3download1. Nella pagina **Instances (Istanze)** scegliere **show (mostra)** nella colonna **Log** dell'istanza per visualizzare il log di Chef. Scorrere verso il basso per trovare il messaggio di log. ``` ... [2015-05-01T21:11:04+00:00] INFO: Loading cookbooks [s3download@0.0.0] [2015-05-01T21:11:04+00:00] INFO: Storing updated cookbooks/s3download/recipes/default.rb in the cache. [2015-05-01T21:11:04+00:00] INFO: ******Downloading an object from S3****** [2015-05-01T21:11:04+00:00] INFO: Processing chef_gem[aws-sdk] action install (s3download::default line 3) [2015-05-01T21:11:05+00:00] INFO: Processing ruby_block[download-object] action run (s3download::default line 8) ... ``` 1. [Utilizzare RDP per accedere all'istanza](workinginstances-rdp.md) ed esaminare i contenuti di `c:\chef`. # Installazione di software Windows **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questi esempi presuppongono che tu abbia già completato l'esempio [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). In caso contrario, ti consigliamo di iniziare da questo esempio, che descrive in particolare come abilitare l'accesso RDP alle istanze. Le istanze di Windows iniziano con Windows Server 2012 R2 Standard, pertanto devi installare software. I dettagli variano a seconda del tipo di software. + Le funzionalità di Windows sono componenti di sistema opzionali, tra cui i framework.NET e Internet Information Services (IIS), che puoi scaricare sulla tua istanza. + Di solito, il software di terze parti viene fornito in un pacchetto di installazione, come un file MSI, che devi scaricare nell'istanza ed eseguire. Anche determinato software Microsoft viene fornito in un pacchetto di installazione. In questa sezione viene descritto come implementare libri di ricette per installare pacchetti e funzionalità Windows. Inoltre, introduce il libro di ricette Windows di Chef, che contiene risorse e funzioni dell'helper che semplificano l'implementazione di ricette per le istanze Windows. **Topics** + [Installazione di una funzionalità di Windows: IIS](cookbooks-101-opsworks-install-software-feature.md) + [Installazione di un pacchetto in un'istanza Windows](cookbooks-101-opsworks-install-software-package.md) # Installazione di una funzionalità di Windows: IIS **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). Le funzionalità di Windows sono un insieme di componenti di sistema opzionali, tra cui i framework.NET e Internet Information Services (IIS). Questo argomento descrive come implementare un ricettario per installare una funzionalità di uso comune, Internet Information Services (IIS). **Nota** [Installazione di un pacchetto](cookbooks-101-opsworks-install-software-package.md) mostra come installare software fornito in un pacchetto di installazione, come un file MSI, che devi scaricare nell'istanza ed eseguire. [Libri di ricette IIS](https://github.com/opscode-cookbooks/iis) [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md) mostra come utilizzare una risorsa `powershell_script` per installare una funzionalità di Windows. Questo esempio mostra un approccio alternativo: usa la risorsa del [ricettario Chef Windows](https://github.com/opscode-cookbooks/windows). `windows_feature` Questo libro di ricette contiene un set di risorse che utilizzano [Gestione e manutenzione immagini distribuzione](https://technet.microsoft.com/en-us/library/dd744256%28v=ws.10%29.aspx) per eseguire un'ampia gamma di attività su Windows, inclusa l'installazione di funzionalità. **Nota** Chef include inoltre un libro di ricette IIS, che puoi utilizzare per gestire IIS. Per ulteriori informazioni, consulta la sezione relativa al [libro di ricette IIS](https://github.com/opscode-cookbooks/iis). **Per configurare il libro di ricette** 1. Vai all'[ GitHub archivio dei libri di cucina di Windows e scarica il ricettario](https://github.com/opscode-cookbooks/windows). `windows` Questo esempio presuppone che il repository `windows` verrà scaricato come file .zip, ma è anche possibile clonare il repository se lo si preferisce. 1. Vai al repository dei libri di cucina [chef\$1handler](https://github.com/opscode-cookbooks/chef_handler) e scarica il ricettario. GitHub `chef-handler` Il libro di ricette `windows` dipende da `chef_handler` e non può essere utilizzato direttamente. Questo esempio presuppone che il repository `chef_handler` verrà scaricato come file .zip, ma è anche possibile clonare il repository se lo si preferisce. 1. Estrarre i libri di ricette `windows` e `chef_handler` nelle directory nella directory dei libri di ricette denominati, rispettivamente, `windows` e `chef_handler`. 1. Creare una directory nella directory dei libri di ricette denominata `install-iis` e accedervi. 1. Aggiungere un file `metadata.rb` a `install-iis` con il contenuto seguente. ``` name "install-iis" version "0.1.0" depends "windows" ``` La direttiva `depends` consente di utilizzare le risorse del libro di ricette `windows` nelle ricette. 1. Aggiungere una directory `recipes` a `install-iis` e aggiungere un file denominato `default.rb` a tale directory che contiene il codice della ricetta seguente. ``` %w{ IIS-WebServerRole IIS-WebServer }.each do |feature| windows_feature feature do action :install end end service 'w3svc' do action [:start, :enable] end ``` La ricetta utilizza la risorsa `windows_feature` del libro di ricette `windows` per installare gli elementi seguenti: 1. Il [ruolo Server Web IIS](https://technet.microsoft.com/en-us/library/cc770634.aspx). 1. Il [Server Web IIS](https://technet.microsoft.com/en-us/library/cc753433%28v=ws.10%29.aspx). La ricetta usa quindi una risorsa [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service) per avviare e abilitare il servizio IIS (W3SVC). **Nota** Per un elenco completo delle funzionalità di Windows disponibili, [utilizzare RDP per accedere all'istanza](workinginstances-rdp.md), aprire una finestra del prompt dei comandi ed eseguire il comando seguente. L'elenco è abbastanza lungo. ``` dism /online /Get-Features ``` 1. Creare un archivio `.zip` che contiene i libri di ricette `install-iis`, `chef_handler` e `windows` e caricare l'archivio in un bucket S3. Rendere pubblico l'archivio e registrare l'URL per utilizzarlo successivamente. Questo esempio presuppone che l'archivio sia denominato `install-iis.zip`. Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Crea uno stack per questo esempio nel modo seguente. Puoi anche utilizzare uno stack Windows esistente. È sufficiente aggiornare i libri di ricette, come descritto di seguito. **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)**. + **Nome: installLIIS** + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome:** IIS + **Nome abbreviato**: iis 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello IIS e [avviarla](workinginstances-starting.md). Adesso puoi installare il libro di ricette ed eseguire la ricetta **Per installare il libro di ricette ed eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository**: **S3** Archive + URL del **repository: l'URL** dell'archivio dei libri di cucina che hai registrato in precedenza. Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack **Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)**](workingstacks-commands.md), che installa la versione più recente dei libri di ricette personalizzati nelle istanze online dello stack. Se è presente una versione precedente dei libri di cucina, verrà sovrascritta da questo comando. 1. Eseguire la ricetta utilizzando il comando dello stack **Execute Recipes (Esegui ricette)** con **Recipes to execute (Ricette da eseguire)** impostato su **install-iis::default**. Questo comando avvia un'esecuzione di Chef, che esegue le ricette specificate. **Nota** Questo esempio utilizza **Execute Recipes** per comodità, ma in genere OpsWorks Stacks [esegue le ricette automaticamente](workingcookbook-assigningcustom.md) assegnandole all'evento del ciclo di vita appropriato. Puoi eseguire tali ricette attivando manualmente l'evento e Puoi utilizzare un comando dello stack per attivare gli eventi Setup e Configure e un [comando di distribuzione](workingapps-deploying.md) per attivare gli eventi Deploy e Undeploy. 1. Per verificare l'installazione, [utilizzare RDP per connettersi all'istanza](workinginstances-rdp.md) e aprire Esplora risorse. Il file system deve avere una directory `C:\inetpub`. Se si verifica l'elenco dei servizi nell'applicazione del pannello di controllo degli strumenti di amministrazione, IIS deve essere quasi in fondo. Tuttavia, sarà denominato World Wide Web Publishing Service, non IIS. # Installazione di un pacchetto in un'istanza Windows **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo esempio presuppone che tu abbia già completato l'esempio [Esecuzione di una ricetta su un'istanza Windows](cookbooks-101-opsworks-opsworks-windows.md). In caso contrario, ti consigliamo di iniziare da questo esempio, che descrive in particolare come abilitare l'accesso RDP alle istanze. Se il tuo software viene fornito in un pacchetto di installazione, come un file MSI, devi scaricare il file nell'istanza ed eseguirlo. Questo esempio illustra come implementare un libro di ricette per installare un pacchetto MSI, il runtime Python, nonché come definire variabili di ambiente associate. Per ulteriori informazioni su come installare le funzionalità di Windows, ad esempio IIS, consulta [Installazione di una funzionalità di Windows: IIS](cookbooks-101-opsworks-install-software-feature.md). **Per configurare il libro di ricette** 1. Creare una directory denominata `installpython` e accedervi. 1. Aggiungere un file `metadata.rb` a `installpython` con il contenuto seguente. ``` name "installpython" version "0.1.0" ``` 1. Aggiungere le directory `recipes` e `files` a `installpython` e aggiungere una directory `default` ai file. 1. Scaricare un pacchetto Python da [Versioni di Python per Windows](https://www.python.org/downloads/windows/) nella directory `files\default` del libro di ricette. Questo esempio installa la versione Windows x86-64 di Python 3.5.0a3, che utilizza un programma di installazione MSI denominato `python-3.4.3.amd64.msi`. 1. Aggiungere un file denominato `default.rb` alla directory `recipes` con il seguente codice ricetta. ``` directory 'C:\tmp' do rights :full_control, 'Everyone' recursive true action :create end cookbook_file 'C:\tmp\python-3.4.3.amd64.msi' do source "python-3.4.3.amd64.msi" rights :full_control, 'Everyone' action :create end windows_package 'python' do source 'C:\tmp\python-3.4.3.amd64.msi' action :install end env "PATH" do value 'c:\python34' delim ";" action :modify end ``` La ricetta effettua le seguenti operazioni: 1. Utilizzare una risorsa [directory](https://docs.chef.io/chef/resources.html#directory) per creare una directory `C:\tmp`. Per ulteriori informazioni su questa risorsa, consulta [Esempio 3: creazione di directory](cookbooks-101-basics-directories.md). 1. Utilizza una risorsa [cookbook\$1file](https://docs.chef.io/chef/resources.html#cookbook-file) per copiare il programma di installazione dalla directory `files\default` del libro di ricette in `C:\tmp`. Per ulteriori informazioni su questa risorsa, consulta [Installazione di un file da un libro di ricette](cookbooks-101-basics-files.md#cookbooks-101-basics-files-cookbook_file). 1. Utilizza una risorsa [windows\$1package](https://docs.chef.io/chef/resources.html#windows-package) per eseguire il programma di installazione MSI, che installa Python in `c:\python34`. Il programma di installazione crea le directory richieste e installa i file, ma non modifica la variabile di ambiente `PATH` del sistema. 1. Utilizza una risorsa [env](https://docs.chef.io/chef/resources.html#env) per aggiungere `c:\python34` al percorso di sistema. È possibile utilizzare la risorsa env per definire le variabili di ambiente. In questo caso, la ricetta consente di eseguire con facilità gli script Python dalla riga di comando aggiungendo `c:\python34` al percorso. + Il nome della risorsa specifica il nome della variabile di ambiente, `PATH` in questo esempio. + L'attributo `value` specifica il valore della variabile, `c:\\python34` per questo esempio (è necessario utilizzare il carattere di escape `\`). + L'azione `:modify` antepone il valore specificato al valore corrente della variabile. + L'attributo `delim` specifica un delimitatore che separa il nuovo valore dal valore esistente, che per questo esempio è `;`. 1. Creare un archivio `.zip` di `installpython`, caricare l'archivio su un bucket S3 e renderlo pubblico. Registrare l'URL dell'archivio per utilizzarlo in seguito. Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Crea uno stack per questo esempio nel modo seguente. Puoi anche utilizzare uno stack Windows esistente. È sufficiente aggiornare i libri di ricette, come descritto di seguito. **Creare uno stack** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. Specificare le impostazioni seguenti, accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)**. + **Nome —** InstallPython + **Regione**: Stati Uniti occidentali (Oregon) Questo esempio funzionerà in qualsiasi regione, ma consigliamo di utilizzare Stati Uniti occidentali (Oregon) per i tutorial. + **Sistema operativo predefinito**: Microsoft Windows Server 2012 R2 1. Scegliere **Add a layer (Aggiungi un livello)** e [aggiungere un livello personalizzato](workinglayers-custom.md) allo stack con le impostazioni seguenti. + **Nome** — Python + **Nome abbreviato**: python 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello Python e [avviarla](workinginstances-starting.md). Una volta che l'istanza è online, puoi installare il libro di ricette ed eseguire la ricetta **Per installare il libro di ricette ed eseguire la ricetta** 1. [Modificare lo stack per abilitare i libri di ricette personalizzati](workingcookbook-installingcustom-enable.md) e specificare le impostazioni seguenti. + **Tipo di repository**: **S3** Archive. + URL del **repository: l'URL** di archivio del libro di cucina che hai registrato in precedenza. Accettare i valori predefiniti per altre impostazioni e scegliere **Save (Salva)** per aggiornare la configurazione dello stack. 1. [Eseguire il comando dello stack **Update Custom Cookbooks (Aggiorna libri di ricette personalizzati)**](workingstacks-commands.md), che installa la versione più recente dei libri di ricette personalizzati nelle istanze online dello stack. Se è presente una versione precedente del libro di ricette, verrà sovrascritta da questo comando. 1. Eseguire la ricetta utilizzando il comando dello stack **Execute Recipes (Esegui ricette)** con **Recipes to execute (Ricette da eseguire)** impostato su **installpython::default**. Questo comando avvia un'esecuzione di Chef, con un elenco di esecuzione costituito da `installpython::default`. **Nota** Questo esempio utilizza **Execute Recipes** per comodità, ma in genere OpsWorks Stacks [esegue le ricette automaticamente](workingcookbook-assigningcustom.md) assegnandole all'evento del ciclo di vita appropriato. Puoi eseguire tali ricette attivando manualmente l'evento e Puoi utilizzare un comando dello stack per attivare gli eventi Setup e Configure e un [comando di distribuzione](workingapps-deploying.md) per attivare gli eventi Deploy e Undeploy. 1. Per verificare l'installazione, [utilizzare RDP per connettersi all'istanza](workinginstances-rdp.md) e aprire Esplora risorse. + Il file system deve avere una directory `C:\Python34`. + Se si esegue `path` dalla riga di comando, si dovrebbe visualizzare quanto riportato di seguito: `PATH=c:\python34;C:\Windows\system32;...` + Se si esegue `python --version` dalla riga di comando, dovrebbe restituire `Python 3.4.3`. # Sostituzione degli attributi integrati **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo argomento si applica solo agli stack Linux. Gli attributi integrati sugli stack Windows non possono essere sostituiti. OpsWorks Stacks installa un set di libri di cucina integrati su ogni istanza. Molti dei libri di ricette integrati supportano i livelli integrati mentre i loro file di attributi definiscono varie impostazioni predefinite di sistema e delle applicazioni, come le impostazioni di configurazione del server Apache. Inserendo queste impostazioni nei file di attributi, puoi personalizzare molte impostazioni di configurazione sostituendo l'attributo integrato corrispondente in uno dei seguenti modi: + Definire l'attributo in un JSON personalizzato. Questo approccio ha il vantaggio di essere semplice e flessibile. Tuttavia, devi immettere manualmente il JSON personalizzato, pertanto non vi sono metodi affidabili per gestire le definizioni degli attributi. + Implementa un libro di ricette personalizzato e definisci l'attributo in un file di attributi `customize.rb`. Questo approccio è meno flessibile rispetto all'utilizzo di un JSON personalizzato, ma è più affidabile poiché puoi mettere i libri di ricette personalizzati sotto il controllo del codice sorgente. In questo argomento viene descritto come utilizzare un file degli attributi del libro di ricette personalizzato per sostituire gli attributi integrati, utilizzando ad esempio il server Apache. Per ulteriori informazioni su come sostituire gli attributi con un JSON personalizzato, consulta [Utilizzo di un JSON personalizzato](workingcookbook-json-override.md). Per una discussione generale su come sostituire gli attributi, consulta [Sostituzione degli attributi](workingcookbook-attributes.md). **Nota** La sostituzione degli attributi rappresenta il modo migliore per personalizzare le impostazioni di configurazione, ma le impostazioni non sono sempre rappresentate dagli attributi. In questo caso, spesso puoi personalizzare il file di configurazione sostituendo il modello che le ricette integrate utilizzano per creare il file di configurazione. Per vedere un esempio, consulta [Sostituzione dei modelli integrati](cookbooks-101-opsworks-templates.md). Gli attributi integrati in genere rappresentano valori nei file modello che le ricette di impostazione utilizzano per creare i file di configurazione. Ad esempio, una delle ricette di impostazione `apache2`, [https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/recipes/default.rb](https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/recipes/default.rb), usa il modello [https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/templates/default/apache2.conf.erb](https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/templates/default/apache2.conf.erb) per creare il file di configurazione principale del server Apache, `httpd.conf` (Amazon Linux) o `apache2.conf` (Ubuntu). Di seguito viene riportato un estratto del file modello: ``` ... # # MaxKeepAliveRequests: The maximum number of requests to allow # during a persistent connection. Set to 0 to allow an unlimited amount. # We recommend you leave this number high, for maximum performance. # MaxKeepAliveRequests <%= node[:apache][:keepaliverequests] %> # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout <%= node[:apache][:keepalivetimeout] %> ## ## Server-Pool Size Regulation (MPM specific) ## ... ``` L'impostazione `KeepAliveTimeout` in questo esempio è il valore dell'attributo `[:apache][:keepalivetimeout]`. Il valore predefinito di questo attributo è definito nel file di attributi `apache2`[`apache.rb` del libro di ricette ](https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/attributes/apache.rb), come mostrato nell'estratto seguente: ``` ... # General settings default[:apache][:listen_ports] = [ '80','443' ] default[:apache][:contact] = 'ops@example.com' default[:apache][:log_level] = 'info' default[:apache][:timeout] = 120 default[:apache][:keepalive] = 'Off' default[:apache][:keepaliverequests] = 100 default[:apache][:keepalivetimeout] = 3 ... ``` **Nota** Per ulteriori informazioni sugli attributi integrati comunemente utilizzati, consulta [Attributi dei libri di ricette predefiniti](attributes-recipes.md). Per supportare la sostituzione degli attributi integrati, tutti i libri di ricette integrati contengono un file degli attributi `customize.rb`, incorporato in tutti i moduli tramite una direttiva `include_attribute`. I file `customize.rb` dei libri di ricette integrati non contengono attributi e non avranno alcun effetto sugli attributi incorporati. Per sostituire gli attributi integrati, devi creare un libro di ricette personalizzato con lo stesso nome del libro di ricette integrato e inserire le definizioni degli attributi personalizzati in un file degli attributi denominato `customize.rb`. Questo file ha la precedenza rispetto alla versione integrata ed è incluso in tutti i moduli correlati. Se definisci gli attributi integrati nel tuo `customize.rb`, questi sostituiscono gli attributi integrati corrispondenti. Questo esempio illustra come sostituire l'attributo `[:apache][:keepalivetimeout]` integrato per impostare il relativo valore su 5 anziché su 3. Puoi utilizzare un approccio simile per qualsiasi attributo integrato. Tuttavia, fai attenzione agli attributi che sostituisci. Ad esempio, la sostituzione degli attributi nello spazio dei nomi `opsworks` potrebbe causare problemi ad alcune ricette integrate. **Importante** Non sostituire gli attributi integrati modificando una copia del file degli attributi integrati. Ad esempio, *potresti* inserire una copia di `apache.rb` nella cartella `apache2/attributes` del tuo libro di ricette personalizzato e modificare alcune impostazioni. Tuttavia, questo file prevale sulla versione integrata e le ricette integrate utilizzeranno la tua versione di `apache.rb`. Se OpsWorks Stacks successivamente modifica il `apache.rb` file integrato, le ricette non otterranno i nuovi valori a meno che non aggiorni manualmente la versione. Utilizzando`customize.rb`, sovrascrivete solo gli attributi specificati; le ricette integrate continuano a ottenere automaticamente up-to-date valori per ogni attributo che non avete sovrascritto. Per iniziare, crea un libro di ricette personalizzato. **Per creare il libro di ricette** 1. Nella directory `opsworks_cookbooks` creare la directory del libro di ricette denominata `apache2` e accedervi. Per ignorare gli attributi integrati, il libro di ricette personalizzato deve avere lo stesso nome del libro di ricette integrato, `apache2` in questo esempio. 1. Nella directory `apache2` creare una directory `attributes`. 1. Aggiungere un file denominato `customize.rb` alla directory `attributes` e utilizzarlo per definire gli attributi del libro di ricette integrato che si desidera ignorare. Per questo esempio il file dovrebbe contenere quanto segue: ``` normal[:apache][:keepalivetimeout] = 5 ``` **Importante** Per sostituire un attributo integrato, un attributo personalizzato deve essere di tipo `normal` o versione successiva e avere esattamente lo stesso nome di nodo dell'attributo integrato corrispondente. Il tipo `normal` garantisce che l'attributo personalizzato prevalga sugli attributi integrati, tutti di tipo `default`. Per ulteriori informazioni, consulta [Precedenza degli attributi](workingcookbook-attributes-precedence.md). 1. Crea un `.zip` archivio di `opsworks_cookbooks` named `opsworks_cookbooks.zip` e carica l'archivio in un bucket Amazon Simple Storage Service (Amazon S3). Per semplicità, [rendere pubblico il file](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html). Registrare l'URL per utilizzarlo successivamente. Puoi anche archiviare i tuoi libri di cucina in un archivio privato di Amazon S3 o in altri tipi di repository. Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). Per utilizzare l'attributo personalizzato, creare uno stack e installare il libro di ricette. **Per utilizzare l'attributo personalizzato** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. 1. Specificare le seguenti impostazioni standard. + **Nome:** ApacheConfig + **Regione**: Stati Uniti occidentali (Oregon) Puoi inserire il tuo stack in qualsiasi regione, ma per i tutorial consigliamo US West (Oregon). + **Chiave SSH predefinita**: una coppia di EC2 chiavi Se devi creare una coppia di EC2 chiavi, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). La coppia di chiavi deve appartenere alla stessa regione AWS dello stack. Scegliere **Advanced (Avanzate) >>**, impostare **Use custom Chef cookbooks (Usa libri di ricette Chef personalizzati)** su **Yes (Sì)**, quindi specificare le seguenti impostazioni. + **Tipo di repository**: **Http** Archive + URL del **repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)** per creare lo stack. **Nota** Questo esempio utilizza il sistema operativo predefinito, ovvero Amazon Linux. Se preferisci, puoi utilizzare Ubuntu. L'unica differenza è che nei sistemi Ubuntu, la ricetta Setup integrata produce un file di configurazione con le stesse impostazioni denominato `apache2.conf` e lo inserisce nella directory `/etc/apache2`. 1. **Scegliete Aggiungi un layer**, quindi [aggiungete un layer Java App Server](layers-java.md) con le impostazioni predefinite allo stack. 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello, quindi avviare l'istanza. Un'istanza t2.micro è sufficiente per questo esempio. 1. Una volta che l'istanza è online, [connettersi a essa con SSH](workinginstances-ssh.md). Il file `httpd.conf` è nella directory `/etc/httpd/conf`. Se si esamina il file, dovrebbe essere visibile l'impostazione `KeepAliveTimeout` personalizzata. Le restanti impostazioni utilizzeranno i valori predefiniti presenti nel file `apache.rb` integrato. La parte pertinente di `httpd.conf` dovrebbe risultare simile alla seguente: ``` ... # # KeepAliveTimeout: Number of seconds to wait for the next request from the # same client on the same connection. # KeepAliveTimeout 5 ... ``` # Sostituzione dei modelli integrati **Importante** Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support). **Nota** Questo argomento si applica solo agli stack Linux. I modelli integrati sugli stack Windows non possono essere sostituiti. Le ricette integrate di OpsWorks Stacks utilizzano modelli per creare file su istanze, principalmente file di configurazione per server, come Apache. Ad esempio, le ricette `apache2` utilizzano il modello [https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/templates/default/apache2.conf.erb](https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/templates/default/apache2.conf.erb) per creare il file di configurazione primario del server Apache, `httpd.conf` (Amazon Linux) o `apache2.conf` (Ubuntu). La maggior parte delle impostazioni di configurazione in questi modelli è rappresentata da attributi, pertanto il modo migliore per personalizzare un file di configurazione consiste nel sostituire gli attributi integrati appropriati. Per vedere un esempio, consulta [Sostituzione degli attributi integrati](cookbooks-101-opsworks-attributes.md). Tuttavia, se le impostazioni che desideri personalizzare non sono rappresentate da attributi integrati o non sono presenti nel modello, devi sostituire il modello stesso. In questo argomento viene descritto come sostituire un modello integrato per specificare un'impostazione di configurazione Apache personalizzata. Puoi fornire risposte di errore personalizzate ad Apache aggiungendo impostazioni `ErrorDocument` al file `httpd.conf`. `apache2.conf.erb` contiene solo alcuni esempi commentati, come illustrato di seguito: ``` ... # # Customizable error responses come in three flavors: # 1) plain text 2) local redirects 3) external redirects # # Some examples: #ErrorDocument 500 "The server made a boo boo." #ErrorDocument 404 /missing.html #ErrorDocument 404 "/cgi-bin/missing_handler.pl" #ErrorDocument 402 http://www.example.com/subscription_info.html ... ``` Poiché queste impostazioni sono commenti hardcoded, non puoi specificare valori personalizzati sostituendo attributi, ma devi sostituire il modello stesso. Tuttavia, diversamente da quanto avviene con gli attributi, non vi è alcun modo per sostituire parti specifiche di un file di modello. Devi creare un libro di ricette personalizzato con lo stesso nome della versione integrata, copiare il file di modello nella stessa sottodirectory e modificare il file in base alle esigenze. Questo argomento mostra come sostituire `apache2.conf.erb` per fornire una risposta personalizzata all'errore 500. Per una discussione generale sulla sostituzione dei modelli, consulta [Utilizzo di modelli personalizzati ](workingcookbook-template-override.md). **Importante** Quando sostituisci un modello integrato, le ricette integrate utilizzano la tua versione personalizzata del modello anziché la versione integrata. Se OpsWorks Stacks aggiorna il modello integrato, il modello personalizzato non è sincronizzato e potrebbe non funzionare correttamente. OpsWorks Stacks non apporta tali modifiche spesso e, quando un modello cambia, OpsWorks Stacks elenca le modifiche e ti offre la possibilità di eseguire l'aggiornamento a una nuova versione. Ti consigliamo di monitorare il [repository OpsWorks Stacks](https://github.com/aws/opsworks-cookbooks) per scoprire le eventuali modifiche e aggiornare manualmente il modello personalizzato in base alle esigenze. Il repository include un ramo distinto per ciascuna versione Chef supportata, pertanto assicurati di essere nel ramo corretto. Per iniziare, crea un libro di ricette personalizzato. **Per creare il libro di ricette** 1. Nella directory `opsworks_cookbooks` creare la directory del libro di ricette denominata `apache2` e accedervi. Per ignorare i modelli integrati, il libro di ricette personalizzato deve avere lo stesso nome del libro di ricette integrato, `apache2` in questo esempio. **Nota** Se hai già completato la procedura guidata [Sostituzione degli attributi integrati](cookbooks-101-opsworks-attributes.md), puoi utilizzare lo stesso libro di ricette `apache2` per questo esempio e saltare il Passaggio 2. 1. Creare un file `metadata.rb` con il seguente contenuto e salvarlo nella directory `apache2`. ``` name "apache2" version "0.1.0" ``` 1. Nella directory `apache2` creare una directory `templates/default`. **Nota** La `templates/default` directory funziona per le istanze Amazon Linux, che utilizzano il `apache2.conf.erb` modello predefinito. Le istanze Ubuntu 14.04 utilizzano un modello `apache2.conf.erb` specifico del sistema operativo, che si trova nella directory `templates/ubuntu-14.04`. Se si desidera che la personalizzazione venga applicata alle istanze Ubuntu 14.04, inoltre, è necessario sovrascrivere anche tale modello. 1. Copiare il [modello `apache2.conf.erb` integrato](https://github.com/aws/opsworks-cookbooks/blob/release-chef-11.10/apache2/templates/default/apache2.conf.erb) nella directory `templates/default`. Aprire il file modello, rimuovere i commenti della riga `ErrorDocument 500` e fornire un messaggio di errore personalizzato, come segue: ``` ... ErrorDocument 500 "A custom error message." #ErrorDocument 404 /missing.html ... ``` 1. Crea un `.zip` archivio di `opsworks_cookbooks` named`opsworks_cookbooks.zip`, quindi carica il file in un bucket Amazon Simple Storage Service (Amazon S3). Per semplicità, [rendere pubblico l'archivio](https://docs.aws.amazon.com/AmazonS3/latest/UG/EditingPermissionsonanObject.html). Registrare l'URL dell'archivio per utilizzarlo in seguito. Puoi anche archiviare i tuoi libri di cucina in un archivio privato di Amazon S3 o in altri tipi di repository. Per ulteriori informazioni, consulta [Repository dei libri di ricette](workingcookbook-installingcustom-repo.md). I contenuti distribuiti ai bucket Amazon S3 potrebbero contenere informazioni dei clienti. Per ulteriori informazioni sulla rimozione di dati sensibili, vedi [Come svuotare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) o [Come eliminare un bucket S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html). **Nota** Per semplicità, questo esempio aggiunge un messaggio di errore hardcoded al modello. Per modificarlo, devi modificare il modello e [reinstallare il libro di ricette](workingcookbook-installingcustom-enable-update.md). Per usufruire di una maggiore flessibilità, puoi [definire un attributo personalizzato predefinito](cookbooks-101-opsworks-attributes.md) per la stringa di errore nel file degli attributi `customize.rb` del libro di ricette personalizzato e assegnare il valore di tale attributo a `ErrorDocument 500`. Ad esempio, se assegni un nome all'attributo `[:apache][:custom][:error500]`, la riga corrispondente in `apache2.conf.erb` sarà simile alla seguente: ``` ... ErrorDocument 500 <%= node[:apache][:custom][:error500] %> #ErrorDocument 404 /missing.html ... ``` Quindi puoi modificare il messaggio di errore personalizzato in qualsiasi momento sostituendo `[:apache][:custom][:error500]`. Se [utilizzi il JSON personalizzato per sostituire l'attributo](workingcookbook-json-override.md), non devi neanche toccare il libro di ricette. Per utilizzare il modello personalizzato, creare uno stack e installare il libro di ricette. **Per utilizzare il modello personalizzato** 1. Aprire la [console OpsWorks Stacks](https://console.aws.amazon.com/opsworks/) e scegliere **Add Stack (Aggiungi stack)**. 1. Specificare le seguenti impostazioni standard: + **Nome:** ApacheTemplate + **Regione**: Stati Uniti occidentali (Oregon) + Chiave **SSH predefinita: una coppia di chiavi** Amazon Elastic Compute Cloud EC2 (Amazon) Se devi creare una coppia di EC2 chiavi Amazon, consulta [Amazon EC2 Key Pairs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). La coppia di chiavi deve appartenere alla stessa regione AWS dell'istanza. Scegliere **Advanced (Avanzate) >>**, scegliere **Use custom Chef cookbooks (Utilizza libri di ricette Chef personalizzati)** per specificare le impostazioni seguenti: + **Tipo di repository**: **Http** Archive + URL del **repository: l'URL** dell'archivio del libro di cucina che hai registrato in precedenza Accettare i valori predefiniti di altre impostazioni e scegliere **Add Stack (Aggiungi stack)** per creare lo stack. 1. **Scegliete Aggiungi un layer**, quindi [aggiungete un layer Java App Server allo](layers-java.md) stack con le impostazioni predefinite. 1. [Aggiungere un'istanza 24/7](workinginstances-add.md) con impostazioni predefinite al livello, quindi avviare l'istanza. Un'istanza t2.micro è sufficiente per questo esempio. 1. Una volta che l'istanza è online, [connettersi a essa con SSH](workinginstances-ssh.md). Il file `httpd.conf` è nella directory `/etc/httpd/conf`. Il file deve contenere la tua impostazione `ErrorDocument` personalizzata, che avrà un aspetto simile al seguente: ``` ... # Some examples: ErrorDocument 500 "A custom error message." #ErrorDocument 404 /missing.html #ErrorDocument 404 "/cgi-bin/missing_handler.pl" #ErrorDocument 402 http://www.example.com/subscription_info.html ... ```