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à.
# Installazione di plugin personalizzati
Amazon Managed Workflows for Apache Airflow supporta il gestore di plugin integrato di Apache Airflow, che consente di utilizzare operatori, hook, sensori o interfacce Apache Airflow personalizzati. Questa pagina descrive i passaggi per installare i plug-in [personalizzati Apache Airflow](https://airflow.incubator.apache.org/plugins.html) sul tuo ambiente Amazon MWAA utilizzando un file. `plugins.zip`
**Contents**
+ [Prerequisiti](#configuring-dag-plugins-prereqs)
+ [Come funziona](#configuring-dag-plugins-how)
+ [Quando usare i plugin](#configuring-dag-plugins-changed)
+ [Panoramica dei plugin personalizzati](#configuring-dag-plugins-overview)
+ [Limiti di directory e dimensioni dei plugin personalizzati](#configuring-dag-plugins-quota)
+ [Esempi di plugin personalizzati](#configuring-dag-plugins-airflow-ex)
+ [Esempio di utilizzo di una struttura di directory piatta in plugins.zip](#configuring-dag-plugins-overview-simple)
+ [Esempio di utilizzo di una struttura di directory annidata in plugins.zip](#configuring-dag-plugins-overview-complex)
+ [Creazione di un file plugins.zip](#configuring-dag-plugins-test-create)
+ [Fase uno: testare i plugin personalizzati utilizzando l'utilità CLI di Amazon MWAA](#configuring-dag-plugins-cli-utility)
+ [Fase due: creare il file plugins.zip](#configuring-dag-plugins-zip)
+ [Caricamento `plugins.zip` su Amazon S3](#configuring-dag-plugins-upload)
+ [Utilizzando il AWS CLI](#configuring-dag-plugins-upload-cli)
+ [Utilizzo della console Amazon S3](#configuring-dag-plugins-upload-console)
+ [Installazione di plugin personalizzati nel tuo ambiente](#configuring-dag-plugins-mwaa-installing)
+ [Specificazione del percorso `plugins.zip` sulla console Amazon MWAA (la prima volta)](#configuring-dag-plugins-mwaa-first)
+ [Specificazione della `plugins.zip` versione sulla console Amazon MWAA](#configuring-dag-plugins-s3-mwaaconsole)
+ [Esempi di casi d'uso per plugins.zip](#configuring-dag-plugins-examples)
+ [Fasi successive](#configuring-dag-plugins-next-up)
## Prerequisiti
Avrai bisogno di quanto segue prima di completare i passaggi di questa pagina.
+ **Autorizzazioni**: Account AWS devi aver ottenuto l'accesso dal tuo amministratore alla politica di controllo degli MWAAFull ConsoleAccess accessi di [Amazon](access-policies.md#console-full-access) per il tuo ambiente. Inoltre, il tuo ambiente Amazon MWAA deve essere autorizzato dal tuo [ruolo di esecuzione](mwaa-create-role.md) ad accedere alle AWS risorse utilizzate dal tuo ambiente.
+ **Accesso****: se è necessario accedere agli archivi pubblici per installare le dipendenze direttamente sul server Web, l'ambiente deve essere configurato con l'accesso al server Web di rete pubblica.** Per ulteriori informazioni, vedi [Modalità di accesso ad Apache Airflow](configuring-networking.md).
+ **Configurazione Amazon S3** **: il bucket [Amazon S3](mwaa-s3-bucket.md) utilizzato per archiviare i plug-in `plugins.zip` personalizzati e DAGs le `requirements.txt` dipendenze Python deve essere configurato con Public Access Blocked e Versioning Enabled.**
## Come funziona
Per eseguire plugin personalizzati nel tuo ambiente, devi fare tre cose:
1. Crea un `plugins.zip` file localmente.
1. Carica il `plugins.zip` file locale nel tuo bucket Amazon S3.
1. Specificare la versione di questo file nel campo **File Plugins** sulla console Amazon MWAA.
**Nota**
Se è la prima volta che carichi un `plugins.zip` file nel tuo bucket Amazon S3, devi anche specificare il percorso del file sulla console Amazon MWAA. Devi completare questo passaggio solo una volta.
## Quando usare i plugin
[I plugin sono necessari solo per estendere l'interfaccia utente di Apache Airflow, come indicato nella documentazione di Apache Airflow.](https://airflow.apache.org/docs/apache-airflow/stable/authoring-and-scheduling/plugins.html#plugins) Gli operatori personalizzati possono essere inseriti direttamente nella cartella insieme al codice. `/dags` `DAG`
Se devi creare le tue integrazioni con sistemi esterni, inseriscile nella `dags` cartella/o in una sottocartella al suo interno, ma non nella `plugins.zip` cartella. In Apache Airflow 2.x, i plugin vengono utilizzati principalmente per estendere l'interfaccia utente.
Allo stesso modo, non è possibile inserire altre dipendenze. `plugins.zip` Possono invece essere archiviati in una posizione nella `/dags` cartella Amazon S3, dove verranno sincronizzati con ogni contenitore Amazon MWAA prima dell'avvio di Apache Airflow.
**Nota**
Qualsiasi file nella `/dags` cartella o in `plugins.zip` quella che non definisce esplicitamente un oggetto Apache Airflow DAG deve essere elencato in un file. `.airflowignore`
## Panoramica dei plugin personalizzati
Il gestore di plugin integrato di Apache Airflow può integrare funzionalità esterne al suo interno semplicemente trascinando i file in una cartella. `$AIRFLOW_HOME/plugins` È possibile utilizzarlo per utilizzare operatori, hook, sensori o interfacce Apache Airflow personalizzati. La sezione seguente fornisce un esempio di strutture di directory piatte e annidate in un ambiente di sviluppo locale e le istruzioni di importazione risultanti, che determinano la struttura delle directory all'interno di un plugins.zip.
### Limiti di directory e dimensioni dei plugin personalizzati
Lo scheduler Apache Airflow e gli operatori cercano plug-in personalizzati durante l'avvio sul contenitore Fargate AWS gestito dall'utente in. `/usr/local/airflow/plugins/*`
+ Struttura **delle** directory. La struttura delle cartelle (at`/*`) si basa sul contenuto del `plugins.zip` file. Ad esempio, se la directory è `plugins.zip` `operators` contenuta come directory di livello principale, la directory verrà estratta nell'ambiente in cui `/usr/local/airflow/plugins/operators` si trova.
+ **Limite di dimensione.** Consigliamo un `plugins.zip` file inferiore a 1 GB. Maggiore è la dimensione di un `plugins.zip` file, maggiore è il tempo di avvio in un ambiente. Sebbene Amazon MWAA non limiti esplicitamente la dimensione di un `plugins.zip` file, se le dipendenze non possono essere installate entro dieci minuti, il servizio Fargate andrà in timeout e tenterà di ripristinare l'ambiente a uno stato stabile.
**Nota**
Per gli ambienti che utilizzano Apache Airflow v2.0.2, Amazon MWAA limita il traffico in uscita sul server web Apache Airflow e non consente l'installazione di plugin o dipendenze Python direttamente sul server web. A partire da Apache Airflow v2.2.2, Amazon MWAA può installare plugin e dipendenze direttamente sul server web.
## Esempi di plugin personalizzati
La sezione seguente utilizza codice di esempio nella guida di *riferimento di Apache Airflow* per spiegare come strutturare l'ambiente di sviluppo locale.
### Esempio di utilizzo di una struttura di directory piatta in plugins.zip
------
#### [ Apache Airflow v3 ]
L'esempio seguente presenta un `plugins.zip` file con una struttura di directory piatta per Apache Airflow v3.
**Example directory piatta con plugins.zip `PythonVirtualenvOperator`**
L'esempio seguente visualizza l'albero di livello principale di un file plugins.zip per il plug-in `PythonVirtualenvOperator` personalizzato in. [Creazione di un plugin personalizzato per Apache Airflow PythonVirtualenvOperator](samples-virtualenv.md)
```
├── virtual_python_plugin.py
```
**Example plugins/virtual\$1python\$1plugin.py**
L'esempio seguente mostra il plugin `PythonVirtualenvOperator` personalizzato.
```
"""
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
from airflow.plugins_manager import AirflowPlugin
import airflow.utils.python_virtualenv
from typing import List
def _generate_virtualenv_cmd(tmp_dir: str, python_bin: str, system_site_packages: bool) -> List[str]:
cmd = ['python3','/usr/local/airflow/.local/lib/python3.7/site-packages/virtualenv', tmp_dir]
if system_site_packages:
cmd.append('--system-site-packages')
if python_bin is not None:
cmd.append(f'--python={python_bin}')
return cmd
airflow.utils.python_virtualenv._generate_virtualenv_cmd=_generate_virtualenv_cmd
class VirtualPythonPlugin(AirflowPlugin):
name = 'virtual_python_plugin'
```
------
#### [ Apache Airflow v2 ]
L'esempio seguente presenta un `plugins.zip` file con una struttura di directory piatta per Apache Airflow v2.
**Example directory piatta con plugins.zip `PythonVirtualenvOperator`**
L'esempio seguente visualizza l'albero di livello principale di un file plugins.zip per il plug-in `PythonVirtualenvOperator` personalizzato in. [Creazione di un plugin personalizzato per Apache Airflow PythonVirtualenvOperator](samples-virtualenv.md)
```
├── virtual_python_plugin.py
```
**Example plugins/virtual\$1python\$1plugin.py**
L'esempio seguente mostra il plugin `PythonVirtualenvOperator` personalizzato.
```
"""
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
from airflow.plugins_manager import AirflowPlugin
import airflow.utils.python_virtualenv
from typing import List
def _generate_virtualenv_cmd(tmp_dir: str, python_bin: str, system_site_packages: bool) -> List[str]:
cmd = ['python3','/usr/local/airflow/.local/lib/python3.7/site-packages/virtualenv', tmp_dir]
if system_site_packages:
cmd.append('--system-site-packages')
if python_bin is not None:
cmd.append(f'--python={python_bin}')
return cmd
airflow.utils.python_virtualenv._generate_virtualenv_cmd=_generate_virtualenv_cmd
class VirtualPythonPlugin(AirflowPlugin):
name = 'virtual_python_plugin'
```
------
### Esempio di utilizzo di una struttura di directory annidata in plugins.zip
------
#### [ Apache Airflow v3 ]
L'esempio seguente presenta un `plugins.zip` file con directory separate per `hooks``operators`, e una `sensors` directory.
**Example plugins.zip**
```
__init__.py
my_airflow_plugin.py
hooks/
|-- __init__.py
|-- my_airflow_hook.py
operators/
|-- __init__.py
|-- my_airflow_operator.py
|-- hello_operator.py
sensors/
|-- __init__.py
|-- my_airflow_sensor.py
```
L'esempio seguente visualizza le istruzioni di importazione nel DAG ([DAGs cartella](https://docs.aws.amazon.com/mwaa/latest/userguide/configuring-dag-folder.html#configuring-dag-folder-how)) che utilizza i plugin personalizzati.
**Example dags/your\$1dag.py**
```
from airflow import DAG
from datetime import datetime, timedelta
from operators.my_airflow_operator import MyOperator
from sensors.my_airflow_sensor import MySensor
from operators.hello_operator import HelloOperator
default_args = {
'owner': 'airflow',
'depends_on_past': False,
'start_date': datetime(2018, 1, 1),
'email_on_failure': False,
'email_on_retry': False,
'retries': 1,
'retry_delay': timedelta(minutes=5),
}
with DAG('customdag',
max_active_runs=3,
schedule_interval='@once',
default_args=default_args) as dag:
sens = MySensor(
task_id='taskA'
)
op = MyOperator(
task_id='taskB',
my_field='some text'
)
hello_task = HelloOperator(task_id='sample-task', name='foo_bar')
sens >> op >> hello_task
```
**Example plugins/my\$1airflow\$1plugin.py**
```
from airflow.plugins_manager import AirflowPlugin
from hooks.my_airflow_hook import *
from operators.my_airflow_operator import *
class PluginName(AirflowPlugin):
name = 'my_airflow_plugin'
hooks = [MyHook]
operators = [MyOperator]
sensors = [MySensor]
```
Gli esempi seguenti presentano ciascuna delle istruzioni di importazione necessarie nei file dei plugin personalizzati.
**Example hooks/my\$1airflow\$1hook.py**
```
from airflow.hooks.base import BaseHook
class MyHook(BaseHook):
def my_method(self):
print("Hello World")
```
**Example sensors/my\$1airflow\$1sensor.py**
```
from airflow.sensors.base import BaseSensorOperator
from airflow.utils.decorators import apply_defaults
class MySensor(BaseSensorOperator):
@apply_defaults
def __init__(self,
*args,
**kwargs):
super(MySensor, self).__init__(*args, **kwargs)
def poke(self, context):
return True
```
**Example operators/my\$1airflow\$1operator.py**
```
from airflow.operators.bash import BaseOperator
from airflow.utils.decorators import apply_defaults
from hooks.my_airflow_hook import MyHook
class MyOperator(BaseOperator):
@apply_defaults
def __init__(self,
my_field,
*args,
**kwargs):
super(MyOperator, self).__init__(*args, **kwargs)
self.my_field = my_field
def execute(self, context):
hook = MyHook('my_conn')
hook.my_method()
```
**Example operators/hello\$1operator.py**
```
from airflow.models.baseoperator import BaseOperator
from airflow.utils.decorators import apply_defaults
class HelloOperator(BaseOperator):
@apply_defaults
def __init__(
self,
name: str,
**kwargs) -> None:
super().__init__(**kwargs)
self.name = name
def execute(self, context):
message = "Hello {}".format(self.name)
print(message)
return message
```
**Segui i passaggi descritti in [Testare i plug-in personalizzati utilizzando l'utilità CLI di Amazon MWAA](#configuring-dag-plugins-cli-utility) e [quindi Creazione di un file plugins.zip](#configuring-dag-plugins-zip) per comprimere i contenuti all'interno della directory.** `plugins` Ad esempio, `cd plugins`.
------
#### [ Apache Airflow v2 ]
L'esempio seguente presenta un `plugins.zip` file con directory separate per`hooks`, `operators` e una directory. `sensors`
**Example plugins.zip**
```
__init__.py
my_airflow_plugin.py
hooks/
|-- __init__.py
|-- my_airflow_hook.py
operators/
|-- __init__.py
|-- my_airflow_operator.py
|-- hello_operator.py
sensors/
|-- __init__.py
|-- my_airflow_sensor.py
```
L'esempio seguente visualizza le istruzioni di importazione nel DAG ([DAGs cartella](https://docs.aws.amazon.com/mwaa/latest/userguide/configuring-dag-folder.html#configuring-dag-folder-how)) che utilizza i plugin personalizzati.
**Example dags/your\$1dag.py**
```
from airflow import DAG
from datetime import datetime, timedelta
from operators.my_airflow_operator import MyOperator
from sensors.my_airflow_sensor import MySensor
from operators.hello_operator import HelloOperator
default_args = {
'owner': 'airflow',
'depends_on_past': False,
'start_date': datetime(2018, 1, 1),
'email_on_failure': False,
'email_on_retry': False,
'retries': 1,
'retry_delay': timedelta(minutes=5),
}
with DAG('customdag',
max_active_runs=3,
schedule_interval='@once',
default_args=default_args) as dag:
sens = MySensor(
task_id='taskA'
)
op = MyOperator(
task_id='taskB',
my_field='some text'
)
hello_task = HelloOperator(task_id='sample-task', name='foo_bar')
sens >> op >> hello_task
```
**Example plugins/my\$1airflow\$1plugin.py**
```
from airflow.plugins_manager import AirflowPlugin
from hooks.my_airflow_hook import *
from operators.my_airflow_operator import *
class PluginName(AirflowPlugin):
name = 'my_airflow_plugin'
hooks = [MyHook]
operators = [MyOperator]
sensors = [MySensor]
```
Gli esempi seguenti presentano ciascuna delle istruzioni di importazione necessarie nei file dei plugin personalizzati.
**Example hooks/my\$1airflow\$1hook.py**
```
from airflow.hooks.base import BaseHook
class MyHook(BaseHook):
def my_method(self):
print("Hello World")
```
**Example sensors/my\$1airflow\$1sensor.py**
```
from airflow.sensors.base import BaseSensorOperator
from airflow.utils.decorators import apply_defaults
class MySensor(BaseSensorOperator):
@apply_defaults
def __init__(self,
*args,
**kwargs):
super(MySensor, self).__init__(*args, **kwargs)
def poke(self, context):
return True
```
**Example operators/my\$1airflow\$1operator.py**
```
from airflow.operators.bash import BaseOperator
from airflow.utils.decorators import apply_defaults
from hooks.my_airflow_hook import MyHook
class MyOperator(BaseOperator):
@apply_defaults
def __init__(self,
my_field,
*args,
**kwargs):
super(MyOperator, self).__init__(*args, **kwargs)
self.my_field = my_field
def execute(self, context):
hook = MyHook('my_conn')
hook.my_method()
```
**Example operators/hello\$1operator.py**
```
from airflow.models.baseoperator import BaseOperator
from airflow.utils.decorators import apply_defaults
class HelloOperator(BaseOperator):
@apply_defaults
def __init__(
self,
name: str,
**kwargs) -> None:
super().__init__(**kwargs)
self.name = name
def execute(self, context):
message = "Hello {}".format(self.name)
print(message)
return message
```
**Segui i passaggi descritti in [Testare i plug-in personalizzati utilizzando l'utilità CLI di Amazon MWAA](#configuring-dag-plugins-cli-utility) e [quindi Creazione di un file plugins.zip](#configuring-dag-plugins-zip) per comprimere i contenuti all'interno della directory.** `plugins` Ad esempio, `cd plugins`.
------
## Creazione di un file plugins.zip
I passaggi seguenti descrivono i passaggi consigliati per creare un file plugins.zip localmente.
### Fase uno: testare i plugin personalizzati utilizzando l'utilità CLI di Amazon MWAA
+ L'utilità CLI (Command Line Interface) replica localmente un ambiente Amazon Managed Workflows for Apache Airflow.
+ La CLI crea localmente un'immagine del contenitore Docker simile a un'immagine di produzione Amazon MWAA. Puoi utilizzarlo per eseguire un ambiente Apache Airflow locale per sviluppare e DAGs testare plugin personalizzati e dipendenze prima della distribuzione su Amazon MWAA.
+ Per eseguire la CLI, fare riferimento a [aws-mwaa-docker-images](https://github.com/aws/amazon-mwaa-docker-images)on. GitHub
### Fase due: creare il file plugins.zip
È possibile utilizzare un'utilità di archiviazione ZIP integrata o qualsiasi altra utilità ZIP (come [7zip](https://www.7-zip.org/download.html)) per creare un file.zip.
**Nota**
L'utilità zip integrata per il sistema operativo Windows può aggiungere sottocartelle quando si crea un file con estensione zip. Ti consigliamo di verificare il contenuto del file plugins.zip prima di caricarlo nel tuo bucket Amazon S3 per assicurarti che non siano state aggiunte altre directory.
1. Cambia le directory nella cartella locale dei plugin Airflow. Ad esempio:
```
myproject$ cd plugins
```
1. Esegui il comando seguente per assicurarti che i contenuti abbiano autorizzazioni eseguibili (solo macOS e Linux).
```
plugins$ chmod -R 755 .
```
1. Comprimi il contenuto **all'interno della cartella**`plugins`.
```
plugins$ zip -r plugins.zip .
```
## Caricamento `plugins.zip` su Amazon S3
Puoi utilizzare la console Amazon S3 o il AWS Command Line Interface (AWS CLI) per caricare un `plugins.zip` file nel tuo bucket Amazon S3.
### Utilizzando il AWS CLI
Il AWS Command Line Interface (AWS CLI) è uno strumento open source che è possibile utilizzare per interagire con i AWS servizi utilizzando i comandi nella shell della riga di comando. Per completare la procedura descritta in questa pagina, è necessario quanto segue:
+ [AWS CLI — Installa la versione 2](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
+ [AWS CLI — Configurazione rapida con `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
**Per caricare utilizzando il AWS CLI**
1. Nel prompt dei comandi, accedi alla directory in cui è archiviato il `plugins.zip` file. Ad esempio:
```
cd plugins
```
1. Usa il seguente comando per elencare tutti i tuoi bucket Amazon S3.
```
aws s3 ls
```
1. Usa il seguente comando per elencare i file e le cartelle nel bucket Amazon S3 per il tuo ambiente.
```
aws s3 ls s3://YOUR_S3_BUCKET_NAME
```
1. Usa il seguente comando per caricare il `plugins.zip` file nel bucket Amazon S3 per il tuo ambiente.
```
aws s3 cp plugins.zip s3://amzn-s3-demo-bucket/plugins.zip
```
### Utilizzo della console Amazon S3
La console Amazon S3 è un'interfaccia utente basata sul Web che puoi utilizzare per creare e gestire le risorse nel tuo bucket Amazon S3.
**Per caricare utilizzando la console Amazon S3**
1. Apri la pagina [Ambienti](https://console.aws.amazon.com/mwaa/home#/environments) sulla console Amazon MWAA.
1. Scegli un ambiente.
1. Seleziona il link al **bucket S3** nel **codice DAG nel riquadro S3 per aprire il bucket di archiviazione nella** console.
1. Scegli **Carica**.
1. **Scegli Aggiungi file.**
1. Seleziona la copia locale del tuo`plugins.zip`, scegli **Carica**.
## Installazione di plugin personalizzati nel tuo ambiente
Questa sezione descrive come installare i plugin personalizzati caricati nel bucket Amazon S3 specificando il percorso del file plugins.zip e specificando la versione del file plugins.zip ogni volta che il file zip viene aggiornato.
### Specificazione del percorso `plugins.zip` sulla console Amazon MWAA (la prima volta)
Se è la prima volta che carichi un `plugins.zip` file nel tuo bucket Amazon S3, devi anche specificare il percorso del file sulla console Amazon MWAA. Devi completare questo passaggio solo una volta.
1. Apri la pagina [Ambienti](https://console.aws.amazon.com/mwaa/home#/environments) sulla console Amazon MWAA.
1. Scegli un ambiente.
1. Scegli **Modifica**.
1. **Nel riquadro del codice DAG di Amazon** S3, **scegli Browse** S3 accanto al file **Plugins (campo** opzionale).
1. Seleziona il `plugins.zip` file nel tuo bucket Amazon S3.
1. Scegliere **Choose (Scegli)**.
1. Scegli **Avanti**, **Aggiorna** ambiente.
### Specificazione della `plugins.zip` versione sulla console Amazon MWAA
È necessario specificare la versione del `plugins.zip` file sulla console Amazon MWAA ogni volta che si carica una nuova versione del file `plugins.zip` nel bucket Amazon S3.
1. Apri la pagina [Ambienti](https://console.aws.amazon.com/mwaa/home#/environments) sulla console Amazon MWAA.
1. Scegli un ambiente.
1. Scegli **Modifica**.
1. **Nel riquadro del codice DAG di Amazon** S3, scegli `plugins.zip` una versione nell'elenco a discesa.
1. Scegli **Next (Successivo)**.
## Esempi di casi d'uso per plugins.zip
+ Scopri come creare un plugin personalizzato in[Plugin personalizzato con Apache Hive e Hadoop](samples-hive.md).
+ Scopri come creare un plug-in personalizzato in[Plugin personalizzato da patchare PythonVirtualenvOperator ](samples-virtualenv.md).
+ Scopri come creare un plug-in personalizzato in[Plugin personalizzato con Oracle](samples-oracle.md).
+ Scopri come creare un plug-in personalizzato in[Modifica del fuso orario di un DAG su Amazon MWAA](samples-plugins-timezone.md).
## Fasi successive
Testa i tuoi DAGs plugin personalizzati e le dipendenze Python localmente usando on. [aws-mwaa-docker-images](https://github.com/aws/amazon-mwaa-docker-images) GitHub