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à.
# IMPLEMENTA MLOps
/*",
"Effect": "Allow"
}
```
## Autorizzazioni relative alle fasi della pipeline
*
*
PUT
Access-Control-Allow-Origin
```
La seguente GIF illustra le istruzioni contenute nella documentazione di Amazon S3 per aggiungere una policy di intestazione CORS utilizzando la console Amazon S3.
![\[Gif su come aggiungere una policy di intestazione CORS utilizzando la console di Amazon S3.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Personalizzazione della gestione degli accessi per i processi Pipelines
---`
| Campo | Definizione |
| --- | --- |
| pipelines | Una stringa statica sempre anteposta. Questa stringa identifica il servizio di orchestrazione della pipeline come origine del processo. |
| executionId | Un buffer randomizzato per l'istanza in esecuzione della pipeline. |
| stepNamePrefix | Il nome della fase specificato dall'utente (fornito nell'argomento `name` della fase della pipeline), limitato ai primi 20 caratteri. |
| entityToken | Un token randomizzato per garantire l'idempotenza dell'entità della fase. |
| failureCount | Il numero attuale di tentativi effettuati per completare il lavoro. |
In questo caso, al nome del processo non viene aggiunto alcun prefisso personalizzato; la policy IAM corrispondente deve corrispondere a questa stringa.
Per gli utenti che attivano il prefisso del processo, il nome del processo sottostante assume la forma seguente, con il prefisso personalizzato specificato come `MyBaseJobName`:
**-**-**-**
Il prefisso personalizzato sostituisce la `pipelines` stringa statica per aiutarti a restringere la selezione di utenti che possono eseguire il job AI come parte di una pipeline. SageMaker
**Restrizioni sulla lunghezza del prefisso**
I nomi dei processi hanno vincoli di lunghezza interni specifici per le singole fasi della pipeline. I vincoli limitano anche la lunghezza consentita del prefisso. I requisiti di lunghezza del prefisso sono i seguenti:
| Fase della pipeline | Lunghezza del prefisso |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Applicazione di prefissi dei processi a una policy IAM
= (
name="",
default_value=
)
```
Di seguito è mostrata un'implementazione di parametri di esempio.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Si passa il parametro durante la creazione della pipeline, come nell'esempio seguente.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
È possibile anche passare un valore di parametro diverso dal valore predefinito all'esecuzione di una pipeline, come mostrato nell'esempio seguente.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Puoi manipolare i parametri con funzioni SageMaker Python SDK come. `[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)` [Per ulteriori informazioni sui parametri, consulta SageMaker Pipelines Parameters.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters)
Per le limitazioni note dei parametri di Pipelines, consulta *[Limitazioni - Parametrizzazione nell'SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
# Fasi delle pipeline
`.
1. Per i caricamenti di cartelle compresse, è necessario fornire i percorsi relativi per il codice e, facoltativamente, i percorsi per un file `requirements.txt` o uno script di inizializzazione all’interno della cartella compressa.
1. Se il canvas include una fase immediatamente precedente alla fase **Esecuzione di codice** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Esecuzione di codice** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Esecuzione di codice** che hai aggiunto, fai clic e trascina il cursore dalla fase **Esecuzione di codice** all’altra fase per creare un arco. Puoi fare riferimento agli output delle fasi **Esecuzione di codice** per le funzioni Python.
## Fase di elaborazione
,
instance_type='ml.m5.xlarge',
instance_count=1)
```
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
inputs = [
ProcessingInput(source=, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
step_process = ProcessingStep(
name="AbaloneProcess",
step_args = sklearn_processor.run(inputs=inputs, outputs=outputs,
code="abalone/preprocessing.py")
)
```
**Passaggio di parametri di runtime**
L'esempio seguente mostra come passare i parametri di runtime da un PySpark processore a un`ProcessingStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.spark.processing import PySparkProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
pipeline_session = PipelineSession()
pyspark_processor = PySparkProcessor(
framework_version='2.4',
role=,
instance_type='ml.m5.xlarge',
instance_count=1,
sagemaker_session=pipeline_session,
)
step_args = pyspark_processor.run(
inputs=[ProcessingInput(source=, destination="/opt/ml/processing/input"),],
outputs=[
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
],
code="preprocess.py",
arguments=None,
)
step_process = ProcessingStep(
name="AbaloneProcess",
step_args=step_args,
)
```
Per ulteriori informazioni sui requisiti delle fasi di elaborazione, consulta [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)documentazione. Per un esempio approfondito, consulta il notebook di esempio [Orchestrate Jobs to Train and Evaluate Models with Amazon SageMaker Pipelines](https://github.com/aws/amazon-sagemaker-examples/blob/62de6a1fca74c7e70089d77e36f1356033adbe5f/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.ipynb). La sezione *Define a Processing Step for Feature Engineering* include ulteriori informazioni.
------
## Fase di addestramento
",
target_attribute_name="my_target_attribute_name",
mode="ENSEMBLING",
sagemaker_session=pipeline_session)
input_training = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-training-data",
target_attribute_name="my_target_attribute_name",
channel_type="training",
)
input_validation = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-validation-data",
target_attribute_name="my_target_attribute_name",
channel_type="validation",
)
step_args = auto_ml.fit(
inputs=[input_training, input_validation]
)
step_automl = AutoMLStep(
name="AutoMLStep",
step_args=step_args,
)
```
**Ottenere la versione migliore del modello**
La fase AutoML addestra automaticamente diversi candidati modello. È possibile ottenere il modello con la metrica obiettivo ottimale dal processo AutoML utilizzando il metodo `get_best_auto_ml_model` come segue. È inoltre necessario utilizzare un `role` IAM per accedere agli artefatti del modello.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Per ulteriori informazioni, consulta il passaggio [AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) in Python SageMaker SDK.
## Fase del modello
* le istanze necessarie per raggiungere la proprietà annidata desiderata nel file. [Per ulteriori informazioni sulla JsonPath notazione, consulta il repository. JsonPath ](https://github.com/json-path/JsonPath)
```
.properties..
```
Di seguito viene illustrato come specificare un bucket Amazon S3 utilizzando la proprietà `ProcessingOutputConfig` di una fase di elaborazione.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Per creare la dipendenza dei dati, passa il bucket a una fase di addestramento come segue.
```
from sagemaker.workflow.pipeline_context import PipelineSession
sklearn_train = SKLearn(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="CensusTrain",
step_args=sklearn_train.fit(inputs=TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train_data"].S3Output.S3Uri
))
)
```
[Per verificare quali proprietà sono riferibili per ogni tipo di passaggio durante la creazione della dipendenza dei dati, consulta Data *[Dependency - Property Reference nell'SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
## Dipendenza personalizzata tra le fasi
",
steps=[step_train_result],
sagemaker_session=,
)
```
Se non ci sono dati o dipendenze personalizzate tra le fasi e si eseguono più fasi in parallelo, il grafo della pipeline ha più di un nodo foglia. Passa tutti questi nodi foglia in un elenco all’argomento `steps` nella definizione della pipeline, come mostrato nell’esempio seguente:
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Quando la pipeline è in esecuzione, entrambi le fasi vengono eseguite in parallelo.
Passa solo i nodi foglia del grafico alla pipeline perché contengono informazioni su tutti le fasi precedenti definite tramite dipendenze dei dati o personalizzate. Quando compila la pipeline, l' SageMaker intelligenza artificiale deduce anche tutti i passaggi successivi che formano il grafico della pipeline e aggiunge ciascuno di essi come passaggio separato alla pipeline.
## Crea una pipeline
",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Configurazione della pipeline
", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Non puoi annidare una variabile della pipeline in un altro oggetto e passarla a una funzione `@step`. L’esempio seguente genera un errore:
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Poiché gli input e gli output di una funzione sono serializzati, esistono limitazioni sui tipi di dati che possono essere passati come input o output da una funzione. Per maggiori dettagli, consulta la sezione *Serializzazione e deserializzazione dei dati* di [Invocare una funzione remota](train-remote-decorator-invocation.md). Le stesse limitazioni si applicano alle funzioni decorate con `@step`.
+ Tutti gli oggetti con un client boto non possono essere serializzati, quindi non puoi passare tali oggetti come input o output da una funzione decorata con `@step`. Ad esempio, le classi client SageMaker Python SDK come `Estimator``Predictor`, e non `Processor` possono essere serializzate.
## Importazioni di funzioni
",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Se utilizzi `JsonGet` con un percorso Amazon S3 nella fase di condizione, devi aggiungere esplicitamente una dipendenza tra la fase di condizione e la fase che genera l’output JSON. Nell’esempio seguente, la fase di condizione viene creata con una dipendenza dalla fase di elaborazione:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Passaggio dei dati tra le fasi con file delle proprietà
= PropertyFile(
name="",
output_name="",
path=""
)
```
Quando crei l'`ProcessingStep`istanza, aggiungi il `property_files` parametro per elencare tutti i file di parametri che il servizio Amazon SageMaker Pipelines deve indicizzare. In questo modo il file di proprietà viene salvato per un uso successivo.
```
property_files=[]
```
Per utilizzare il file di proprietà in una fase condizionale, aggiungi `property_file` alla condizione che passi alla fase condizionale, come illustrato nell'esempio seguente, per eseguire query sul file JSON per la proprietà desiderata utilizzando il parametro `json_path`.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Per esempi più approfonditi, consulta *[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* nell'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Caching delle fasi della pipeline
"
}
}
```
Il campo `Enabled` indica se la memorizzazione nella cache è attivata per la fase specifica. Puoi impostare il campo su`true`, che indica all' SageMaker IA di cercare di trovare un'esecuzione precedente del passaggio con gli stessi attributi. In alternativa, puoi impostare il campo su`false`, che indica all' SageMaker IA di eseguire il passaggio ogni volta che viene eseguita la pipeline. `ExpireAfter`è una stringa in formato di [durata ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) che definisce il periodo di timeout. La durata `ExpireAfter` può essere un valore espresso in anni, mesi, settimane, giorni, ore o minuti. Ogni valore è costituito da un numero seguito da una lettera che indica l'unità di durata. Esempio:
+ "30d" = 30 giorni
+ "5y" = 5 anni
+ "T16m" = 16 minuti
+ "30DT5h" = 30 giorni e 5 ore.
La discussione seguente descrive la procedura per attivare la memorizzazione nella cache per pipeline nuove o preesistenti utilizzando l'SDK Amazon Python SageMaker .
**Attivazione della memorizzazione nella cache per nuove pipeline**
Per le nuove pipeline, inizializza un'istanza `CacheConfig` con `enable_caching=True` e forniscila come input per la fase della pipeline. L'esempio seguente attiva la memorizzazione nella cache con un periodo di timeout di 1 ora per una fase di addestramento:
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.steps import CacheConfig
cache_config = CacheConfig(enable_caching=True, expire_after="PT1H")
estimator = Estimator(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=estimator.fit(inputs=inputs),
cache_config=cache_config
)
```
**Attivazione della memorizzazione nella cache per pipeline preesistenti**
Per attivare la memorizzazione nella cache per pipeline preesistenti e già definite, attiva la proprietà `enable_caching` per la fase e imposta un valore di timeout per `expire_after`. Infine, aggiorna la pipeline con `pipeline.upsert()` o `pipeline.update()`. Una volta eseguito di nuovo, il seguente esempio di codice attiva la memorizzazione nella cache con un periodo di timeout di 1 ora per una fase di addestramento:
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.steps import CacheConfig
from sagemaker.workflow.pipeline import Pipeline
cache_config = CacheConfig(enable_caching=True, expire_after="PT1H")
estimator = Estimator(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=estimator.fit(inputs=inputs),
cache_config=cache_config
)
# define pipeline
pipeline = Pipeline(
steps=[step_train]
)
# additional step for existing pipelines
pipeline.update()
# or, call upsert() to update the pipeline
# pipeline.upsert()
```
In alternativa, aggiorna la configurazione della cache dopo aver già definito la pipeline (preesistente), consentendo l'esecuzione continua del codice. Il seguente esempio di codice illustra questo metodo:
```
# turn on caching with timeout period of one hour
pipeline.steps[0].cache_config.enable_caching = True
pipeline.steps[0].cache_config.expire_after = "PT1H"
# additional step for existing pipelines
pipeline.update()
# or, call upsert() to update the pipeline
# pipeline.upsert()
```
Per esempi di codice più dettagliati e una discussione su come i parametri di Python SDK influiscono sulla memorizzazione nella cache, consulta Caching [Configuration nella documentazione](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#caching-configuration) di Amazon Python SDK. SageMaker
# Disattivazione della memorizzazione nella cache delle fasi
"
}
}
```
Nota che l'attributo `ExpireAfter` viene ignorato quando `Enabled` è `false`.
Per disattivare la memorizzazione nella cache per un passaggio della pipeline utilizzando l'SDK Amazon SageMaker Python, definisci la pipeline del passaggio della pipeline, disattiva la proprietà e aggiorna la `enable_caching` pipeline.
Una volta eseguito di nuovo, il seguente esempio di codice disattiva la memorizzazione nella cache per una fase di addestramento:
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.steps import CacheConfig
from sagemaker.workflow.pipeline import Pipeline
cache_config = CacheConfig(enable_caching=False, expire_after="PT1H")
estimator = Estimator(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=estimator.fit(inputs=inputs),
cache_config=cache_config
)
# define pipeline
pipeline = Pipeline(
steps=[step_train]
)
# update the pipeline
pipeline.update()
# or, call upsert() to update the pipeline
# pipeline.upsert()
```
In alternativa, disattiva la proprietà `enable_caching` dopo aver già definito la pipeline, consentendo l'esecuzione di un codice continuo. Il seguente esempio di codice illustra questa soluzione:
```
# turn off caching for the training step
pipeline.steps[0].cache_config.enable_caching = False
# update the pipeline
pipeline.update()
# or, call upsert() to update the pipeline
# pipeline.upsert()
```
Per esempi di codice più dettagliati e una discussione su come i parametri di Python SDK influiscono sulla memorizzazione nella cache, consulta Caching [Configuration nella documentazione](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#caching-configuration) di Amazon Python SDK. SageMaker
# Attributi chiave della cache predefiniti per tipo di fase della pipeline
----event-pattern --description --role-arn --tags
```
+ **Pianificazione**: la regola viene avviata regolarmente in base a una pianificazione specificata. È possibile utilizzare una pianificazione a frequenza fissa che viene avviata regolarmente per un determinato numero di minuti, ore o settimane. Puoi anche usare un'espressione cron per creare una pianificazione più dettagliata, ad esempio "il primo lunedì di ogni mese alle 8:00". La pianificazione non è supportata su un bus di eventi partner o personalizzato. È possibile creare una regola con pianificazione utilizzando il seguente comando:
```
aws events put-rule --name --schedule-expression --description --role-arn --tags
```
1. Aggiungi una o più destinazioni da richiamare quando un evento corrisponde al tuo modello di evento o quando viene avviata la pianificazione. È possibile aggiungere fino a 5 destinazioni per regola. Per ciascuna destinazione, occorre specificare:
+ ARN: l'ARN della risorsa della tua pipeline.
+ Ruolo ARN: l'ARN del ruolo EventBridge deve assumere per eseguire la pipeline.
+ Parametri: parametri della pipeline Amazon SageMaker AI da passare.
1. Esegui il comando seguente per passare una pipeline Amazon SageMaker AI come destinazione alla tua regola utilizzando [put-targets](https://docs.aws.amazon.com/cli/latest/reference/events/put-targets.html):
```
aws events put-targets --rule --event-bus-name --targets "[{\"Id\": , \"Arn\": , \"RoleArn\": , \"SageMakerPipelineParameter\": { \"SageMakerParameterList\": [{\"Name\": , \"Value\": }]} }]"]
```
## Pianifica una pipeline con SageMaker Python SDK
",
at=datetime(2023, 12, 13, 10, 15, 20)
)
# schedules a pipeline run every 5 minutes
my_rate_schedule = PipelineSchedule(
name="",
rate=(5, "minutes")
)
# schedules a pipeline run at 10:15am UTC on the last Friday of each month during the years 2022 to 2023
my_cron_schedule = PipelineSchedule(
name="",
cron="15 10 ? * 6L 2022-2023"
)
```
**Nota**
Se crei una pianificazione una tantum e devi accedere alla funzionalità per l’ora corrente, utilizza `datetime.utcnow()` invece di `datetime.now()`. Quest'ultimo non memorizza il contesto della zona corrente e determina un intervallo di tempo errato passato a EventBridge.
### Collegamento del trigger alla pipeline
",
steps=[...],
sagemaker_session=,
)
custom_schedule = PipelineSchedule(
name="",
at=datetime(year=2023, month=12, date=25, hour=10, minute=30, second=30)
)
scheduled_pipeline.put_triggers(triggers=[custom_schedule], role_arn=)
```
### Descrizione dei trigger correnti
")
```
### Pulizia delle risorse del trigger
"])
```
**Nota**
Quando elimini i trigger, tieni presente le limitazioni seguenti:
L'opzione per eliminare i trigger specificando i nomi dei trigger è disponibile solo in Python SageMaker SDK. L’eliminazione della pipeline nella CLI o con una chiamata API `DeletePipeline` non elimina i trigger. Di conseguenza, i trigger diventano orfani e l' SageMaker IA tenta di avviare un'esecuzione per una pipeline inesistente.
Inoltre, se stai utilizzando un'altra sessione del notebook o hai già eliminato la destinazione della pipeline, pulisci le pianificazioni orfane tramite la [CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/scheduler/delete-schedule.html) o la console dello scheduler. EventBridge
# Integrazione con Amazon SageMaker Experiments
` con l'ARN usato per creare l'istanza del notebook.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
+ Affidati al responsabile del servizio di SageMaker intelligenza artificiale seguendo i passaggi descritti in [Modifica di una politica di fiducia dei ruoli](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli). Aggiungi il seguente frammento di dichiarazione alla relazione di attendibilità del tuo ruolo:
```
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
```
#### Configurare l'ambiente
"
export AWS_REGION=""
```
1. Utilizza il comando seguente per associare il provider OIDC al cluster. Per ulteriori informazioni, consulta [Abilitazione dei ruoli IAM per gli account di servizio nel cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html).
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${AWS_REGION} --approve
```
L'aspetto dell'output deve essere simile al seguente:
```
[_] eksctl version 0.10.1
[_] using region us-east-1
[_] IAM OpenID Connect provider is associated with cluster "my-cluster" in "us-east-1"
```
Ora che il cluster dispone di un provider di identità OIDC, puoi creare un ruolo e concedere a Kubernetes l'autorizzazione ad ServiceAccount assumerlo.
##### Ottieni l'ID OIDC
`, `` e `` con i valori corrispondenti al tuo cluster.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks..amazonaws.com/id/"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks..amazonaws.com/id/:aud": "sts.amazonaws.com",
"oidc.eks..amazonaws.com/id/:sub": "system:serviceaccount:sagemaker-k8s-operator-system:sagemaker-k8s-operator-default"
}
}
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws-cn:iam::111122223333:oidc-provider/oidc.eks..amazonaws.com/id/"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks..amazonaws.com/id/:aud": "sts.amazonaws.com",
"oidc.eks..amazonaws.com/id/:sub": "system:serviceaccount:sagemaker-k8s-operator-system:sagemaker-k8s-operator-default"
}
}
}
]
}
```
------
1. Esegui il seguente comando per creare un ruolo con relazione di attendibilità definita in `trust.json`. Questo ruolo consente al cluster Amazon EKS di ottenere e aggiornare le credenziali da IAM.
```
aws iam create-role --region ${AWS_REGION} --role-name --assume-role-policy-document file://trust.json --output=text
```
L'aspetto dell'output deve essere simile al seguente:
```
ROLE arn:aws:iam::123456789012:role/my-role 2019-11-22T21:46:10Z / ABCDEFSFODNN7EXAMPLE my-role
ASSUMEROLEPOLICYDOCUMENT 2012-10-17
STATEMENT sts:AssumeRoleWithWebIdentity Allow
STRINGEQUALS sts.amazonaws.com system:serviceaccount:sagemaker-k8s-operator-system:sagemaker-k8s-operator-default
PRINCIPAL arn:aws:iam::123456789012:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/
```
Prendi nota di `ROLE ARN`; passerai questo valore al tuo operatore.
##### Allega la AmazonSageMakerFullAccess policy al ruolo
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
```
Kubernetes ServiceAccount `sagemaker-k8s-operator-default` dovrebbe avere le autorizzazioni. `AmazonSageMakerFullAccess` Confermalo mentre installi l'operatore.
##### Distribuzione dell'operatore
"
export AWS_REGION=""
```
1. Utilizza il comando seguente per associare il provider OIDC al cluster. Per ulteriori informazioni, consulta [Abilitazione dei ruoli IAM per gli account di servizio nel cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html).
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${AWS_REGION} --approve
```
L'aspetto dell'output deve essere simile al seguente:
```
[_] eksctl version 0.10.1
[_] using region us-east-1
[_] IAM OpenID Connect provider is associated with cluster "my-cluster" in "us-east-1"
```
Ora che il cluster dispone di un provider di identità OIDC, crea un ruolo e concedi a Kubernetes ServiceAccount l'autorizzazione ad assumere il ruolo.
##### Ottieni il tuo ID OIDC
`, ``, `` e `` con i valori corrispondenti al tuo cluster. Ai fini di questa guida, `my-namespace` viene utilizzato per il valore ``.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks..amazonaws.com/id/"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks..amazonaws.com/id/:aud": "sts.amazonaws.com",
"oidc.eks..amazonaws.com/id/:sub": "system:serviceaccount::sagemaker-k8s-operator-default"
}
}
}
]
}
```
------
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws-cn:iam::111122223333:oidc-provider/oidc.eks..amazonaws.com/id/"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks..amazonaws.com/id/:aud": "sts.amazonaws.com",
"oidc.eks..amazonaws.com/id/:sub": "system:serviceaccount::sagemaker-k8s-operator-default"
}
}
}
]
}
```
------
1. Esegui il seguente comando per creare un ruolo con relazione di attendibilità definita in `trust.json`. Questo ruolo consente al cluster Amazon EKS di ottenere e aggiornare le credenziali da IAM.
```
aws iam create-role --region ${AWS_REGION} --role-name --assume-role-policy-document file://trust.json --output=text
```
L'aspetto dell'output deve essere simile al seguente:
```
ROLE arn:aws:iam::123456789012:role/my-role 2019-11-22T21:46:10Z / ABCDEFSFODNN7EXAMPLE my-role
ASSUMEROLEPOLICYDOCUMENT 2012-10-17
STATEMENT sts:AssumeRoleWithWebIdentity Allow
STRINGEQUALS sts.amazonaws.com system:serviceaccount:my-namespace:sagemaker-k8s-operator-default
PRINCIPAL arn:aws:iam::123456789012:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/
```
Prendi nota di `ROLE ARN`. Passerai questo valore al tuo operatore.
##### AmazonSageMakerFullAccess Allega la politica al tuo ruolo
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
```
Kubernetes ServiceAccount `sagemaker-k8s-operator-default` dovrebbe avere le autorizzazioni. `AmazonSageMakerFullAccess` Confermalo mentre installi l'operatore.
##### Distribuisci l'operatore nel tuo spazio dei nomi
/g' operator.yaml
```
1. Modifica il file `operator.yaml` per inserire le risorse nel tuo `eks.amazonaws.com/role-arn`. Sostituisci l'ARN qui con il nome della risorsa Amazon (ARN) per il ruolo basato su OIDC che hai creato.
1. Usa il comando seguente per distribuire il cluster:
```
kubectl apply -f operator.yaml
```
##### Distribuisci l'operatore nel tuo spazio dei nomi utilizzando i grafici Helm
helm install --n op operator_chart/
```
1. Dopo un instante, il grafico viene installato con il nome `sagemaker-operator`. Verifica che l’installazione sia andata a buon fine eseguendo il comando riportato di seguito:
```
helm ls
```
L'aspetto dell'output deve essere simile al seguente:
```
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
sagemaker-operator my-namespace 1 2019-11-20 23:14:59.6777082 +0000 UTC deployed sagemaker-k8s-operator-0.1.0
```
##### Verifica la distribuzione dell'operatore nel tuo spazio dei nomi
```
#### Elimina gli operatori basati sullo spazio dei nomi
```
##### Operatori installati con grafici Helm
# delete the crds
helm delete crds
# optionally delete the namespace
kubectl delete namespace
```
### Risoluzione dei problemi
```
+ Se il lavoro è stato creato in SageMaker AI, puoi usare il seguente comando per visualizzare il `STATUS` e il`SageMaker Job Name`:
```
kubectl get
```
+ È possibile utilizzare `smlogs` per trovare la causa del problema utilizzando il seguente comando:
```
kubectl smlogs
```
+ È inoltre possibile utilizzare il comando `describe` per ricevere ulteriori dettagli sul processo utilizzando il comando seguente. L'output ha un campo `additional` che contiene ulteriori informazioni sullo stato del processo.
```
kubectl describe
```
+ Se il lavoro non è stato creato in SageMaker AI, utilizza i log del pod dell'operatore per trovare la causa del problema nel modo seguente:
```
$ kubectl get pods -A | grep sagemaker
# Output:
sagemaker-k8s-operator-system sagemaker-k8s-operator-controller-manager-5cd7df4d74-wh22z 2/2 Running 0 3h33m
$ kubectl logs -p -c manager -n sagemaker-k8s-operator-system
```
#### Eliminazione di un CRD dell'operatore
```
1. Modifica il processo per eliminare il finalizzatore rimuovendo le due righe seguenti dal file. Salva il file e il processo verrà eliminato.
```
finalizers:
- sagemaker-operator-finalizer
```
### Immagini e SMlogs in ogni regione
` e `outputPath` con il tuo bucket Amazon S3 a cui il ruolo di esecuzione SageMaker AI ha accesso in scrittura. `roleArn`Devono disporre delle autorizzazioni affinché l' SageMaker IA possa accedere ad Amazon S3, CloudWatch Amazon e altri servizi per tuo conto. Per ulteriori informazioni sulla creazione di un' SageMaker IA ExecutionRole, consulta [SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html#sagemaker-roles-createtrainingjob-perms) Roles. Applica il file YAML usando il comando seguente:
```
kubectl apply -f xgboost-mnist-trainingjob.yaml
```
### Crea un TrainingJob diagramma utilizzando un Helm
Annotations:
API Version: sagemaker.aws.amazon.com/v1
Kind: TrainingJob
Metadata:
Creation Timestamp: 2019-11-20T23:42:35Z
Finalizers:
sagemaker-operator-finalizer
Generation: 2
Resource Version: 23119
Self Link: /apis/sagemaker.aws.amazon.com/v1/namespaces/default/trainingjobs/xgboost-mnist-from-for-s3
UID: 6d7uiui-0bef-11ea-b94e-0ed467example
Spec:
Algorithm Specification:
Training Image: 8256416981234.dkr.ecr.us-east-2.amazonaws.com/xgboost:1
Training Input Mode: File
Hyper Parameters:
Name: eta
Value: 0.2
Name: gamma
Value: 4
Name: max_depth
Value: 5
Name: min_child_weight
Value: 6
Name: num_class
Value: 10
Name: num_round
Value: 10
Name: objective
Value: multi:softmax
Name: silent
Value: 0
Input Data Config:
Channel Name: train
Compression Type: None
Content Type: text/csv
Data Source:
S 3 Data Source:
S 3 Data Distribution Type: FullyReplicated
S 3 Data Type: S3Prefix
S 3 Uri: https://s3-us-east-2.amazonaws.com/amzn-s3-demo-bucket/sagemaker/xgboost-mnist/train/
Channel Name: validation
Compression Type: None
Content Type: text/csv
Data Source:
S 3 Data Source:
S 3 Data Distribution Type: FullyReplicated
S 3 Data Type: S3Prefix
S 3 Uri: https://s3-us-east-2.amazonaws.com/amzn-s3-demo-bucket/sagemaker/xgboost-mnist/validation/
Output Data Config:
S 3 Output Path: s3://amzn-s3-demo-bucket/sagemaker/xgboost-mnist/xgboost/
Region: us-east-2
Resource Config:
Instance Count: 1
Instance Type: ml.m4.xlarge
Volume Size In GB: 5
Role Arn: arn:aws:iam::12345678910:role/service-role/AmazonSageMaker-ExecutionRole
Stopping Condition:
Max Runtime In Seconds: 86400
Training Job Name: xgboost-mnist-from-for-s3-6d7fa0af0bef11eab94e0example
Status:
Cloud Watch Log URL: https://us-east-2.console.aws.amazon.com/cloudwatch/home?region=us-east-2#logStream:group=/aws/sagemaker/TrainingJobs;prefix=;streamFilter=typeLogStreamPrefix
Last Check Time: 2019-11-20T23:44:29Z
Sage Maker Training Job Name: xgboost-mnist-from-for-s3-6d7fa0af0bef11eab94eexample
Secondary Status: Downloading
Training Job Status: InProgress
Events:
```
### Visualizza i registri da TrainingJobs
```
#### Generato TrainingJobs
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"sagemaker.aws.amazon.com/v1","kind":"HyperparameterTuningJob","metadata":{"annotations":{},"name":"xgboost-mnist-hpo","namespace":...
API Version: sagemaker.aws.amazon.com/v1
Kind: HyperparameterTuningJob
Metadata:
Creation Timestamp: 2019-10-17T01:15:52Z
Finalizers:
sagemaker-operator-finalizer
Generation: 2
Resource Version: 8167
Self Link: /apis/sagemaker.aws.amazon.com/v1/namespaces/default/hyperparametertuningjobs/xgboost-mnist-hpo
UID: a92f5e3c-f07b-11e9-bf6c-06d6f303uidu
Spec:
Hyper Parameter Tuning Job Config:
Hyper Parameter Tuning Job Objective:
Metric Name: validation:error
Type: Minimize
Parameter Ranges:
Integer Parameter Ranges:
Max Value: 20
Min Value: 10
Name: num_round
Scaling Type: Linear
Resource Limits:
Max Number Of Training Jobs: 10
Max Parallel Training Jobs: 10
Strategy: Bayesian
Training Job Early Stopping Type: Off
Hyper Parameter Tuning Job Name: xgboostha92f5e3cf07b11e9bf6c06d6
Region: us-east-2
Training Job Definition:
Algorithm Specification:
Training Image: 12345678910.dkr.ecr.us-east-2.amazonaws.com/xgboost:1
Training Input Mode: File
Input Data Config:
Channel Name: train
Content Type: text/csv
Data Source:
s3DataSource:
s3DataDistributionType: FullyReplicated
s3DataType: S3Prefix
s3Uri: https://s3-us-east-2.amazonaws.com/amzn-s3-demo-bucket/sagemaker/xgboost-mnist/train/
Channel Name: validation
Content Type: text/csv
Data Source:
s3DataSource:
s3DataDistributionType: FullyReplicated
s3DataType: S3Prefix
s3Uri: https://s3-us-east-2.amazonaws.com/amzn-s3-demo-bucket/sagemaker/xgboost-mnist/validation/
Output Data Config:
s3OutputPath: https://s3-us-east-2.amazonaws.com/amzn-s3-demo-bucket/sagemaker/xgboost-mnist/xgboost
Resource Config:
Instance Count: 1
Instance Type: ml.m4.xlarge
Volume Size In GB: 5
Role Arn: arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole
Static Hyper Parameters:
Name: base_score
Value: 0.5
Name: booster
Value: gbtree
Name: csv_weights
Value: 0
Name: dsplit
Value: row
Name: grow_policy
Value: depthwise
Name: lambda_bias
Value: 0.0
Name: max_bin
Value: 256
Name: max_leaves
Value: 0
Name: normalize_type
Value: tree
Name: objective
Value: reg:linear
Name: one_drop
Value: 0
Name: prob_buffer_row
Value: 1.0
Name: process_type
Value: default
Name: rate_drop
Value: 0.0
Name: refresh_leaf
Value: 1
Name: sample_type
Value: uniform
Name: scale_pos_weight
Value: 1.0
Name: silent
Value: 0
Name: sketch_eps
Value: 0.03
Name: skip_drop
Value: 0.0
Name: tree_method
Value: auto
Name: tweedie_variance_power
Value: 1.5
Stopping Condition:
Max Runtime In Seconds: 86400
Status:
Best Training Job:
Creation Time: 2019-10-17T01:16:14Z
Final Hyper Parameter Tuning Job Objective Metric:
Metric Name: validation:error
Value:
Objective Status: Succeeded
Training End Time: 2019-10-17T01:20:24Z
Training Job Arn: arn:aws:sagemaker:us-east-2:123456789012:training-job/xgboostha92f5e3cf07b11e9bf6c06d6-009-4sample
Training Job Name: xgboostha92f5e3cf07b11e9bf6c06d6-009-4c7a3059
Training Job Status: Completed
Training Start Time: 2019-10-17T01:18:35Z
Tuned Hyper Parameters:
Name: num_round
Value: 18
Hyper Parameter Tuning Job Status: Completed
Last Check Time: 2019-10-17T01:21:01Z
Sage Maker Hyper Parameter Tuning Job Name: xgboostha92f5e3cf07b11e9bf6c06d6
Training Job Status Counters:
Completed: 10
In Progress: 0
Non Retryable Error: 0
Retryable Error: 0
Stopped: 0
Total Error: 0
Events:
```
### Visualizza i log da HyperparameterTuningJobs
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"sagemaker.aws.amazon.com/v1","kind":"BatchTransformJob","metadata":{"annotations":{},"name":"xgboost-mnist","namespace"...
API Version: sagemaker.aws.amazon.com/v1
Kind: BatchTransformJob
Metadata:
Creation Timestamp: 2019-11-18T03:44:00Z
Finalizers:
sagemaker-operator-finalizer
Generation: 2
Resource Version: 21990924
Self Link: /apis/sagemaker.aws.amazon.com/v1/namespaces/default/batchtransformjobs/xgboost-mnist
UID: a88fb198-09b5-11ea-ac44-0aa8a9UIDNUM
Spec:
Model Name: TrainingJob-20190814SMJOb-IKEB
Region: us-east-1
Transform Input:
Content Type: text/csv
Data Source:
S 3 Data Source:
S 3 Data Type: S3Prefix
S 3 Uri: s3://amzn-s3-demo-bucket/mnist_kmeans_example/input
Transform Job Name: xgboost-mnist-a88fb19809b511eaac440aa8a9SMJOB
Transform Output:
S 3 Output Path: s3://amzn-s3-demo-bucket/mnist_kmeans_example/output
Transform Resources:
Instance Count: 1
Instance Type: ml.m4.xlarge
Status:
Last Check Time: 2019-11-19T22:50:40Z
Sage Maker Transform Job Name: xgboost-mnist-a88fb19809b511eaac440aaSMJOB
Transform Job Status: Completed
Events:
```
### Visualizza i registri da BatchTransformJobs
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"sagemaker.aws.amazon.com/v1","kind":"HostingDeployment","metadata":{"annotations":{},"name":"host-xgboost","namespace":"def..."
API Version: sagemaker.aws.amazon.com/v1
Kind: HostingDeployment
Metadata:
Creation Timestamp: 2019-11-22T19:40:00Z
Finalizers:
sagemaker-operator-finalizer
Generation: 1
Resource Version: 4258134
Self Link: /apis/sagemaker.aws.amazon.com/v1/namespaces/default/hostingdeployments/host-xgboost
UID: def0e83e-0d5f-11ea-aa45-0a3507uiduid
Spec:
Containers:
Container Hostname: xgboost
Image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/xgboost:latest
Model Data URL: s3://amzn-s3-demo-bucket/inference/xgboost-mnist/model.tar.gz
Models:
Containers:
xgboost
Execution Role Arn: arn:aws:iam::123456789012:role/service-role/AmazonSageMaker-ExecutionRole
Name: xgboost-model
Primary Container: xgboost
Production Variants:
Initial Instance Count: 1
Instance Type: ml.c5.large
Model Name: xgboost-model
Variant Name: all-traffic
Region: us-east-2
Status:
Creation Time: 2019-11-22T19:40:04Z
Endpoint Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint/host-xgboost-def0e83e0d5f11eaaaexample
Endpoint Config Name: host-xgboost-1-def0e83e0d5f11e-e08f6c510d5f11eaaa450aexample
Endpoint Name: host-xgboost-def0e83e0d5f11eaaa450a350733ba06
Endpoint Status: Creating
Endpoint URL: https://runtime.sagemaker.us-east-2.amazonaws.com/endpoints/host-xgboost-def0e83e0d5f11eaaaexample/invocations
Last Check Time: 2019-11-22T19:43:57Z
Last Modified Time: 2019-11-22T19:40:04Z
Model Names:
Name: xgboost-model
Value: xgboost-model-1-def0e83e0d5f11-df5cc9fd0d5f11eaaa450aexample
Events:
```
Il campo di stato fornisce ulteriori informazioni utilizzando i seguenti campi:
+ `Additional`: ulteriori informazioni sullo stato dell’implementazione in hosting. Questo campo è facoltativo e viene compilato solo in caso di errore.
+ `Creation Time`: Quando l'endpoint è stato creato in SageMaker AI.
+ `Endpoint ARN`: L'ARN dell'endpoint SageMaker AI.
+ `Endpoint Config Name`: il nome SageMaker AI della configurazione dell'endpoint.
+ `Endpoint Name`: il nome SageMaker AI dell'endpoint.
+ `Endpoint Status`: lo stato dell'endpoint.
+ `Endpoint URL`: l'URL HTTPS che può essere utilizzato per accedere all'endpoint. Per ulteriori informazioni, consulta [Implementare un modello sui servizi di hosting SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html).
+ `FailureReason`: se un comando di creazione, aggiornamento o eliminazione non riesce, la causa viene mostrata di seguito.
+ `Last Check Time`: l'ultima volta in cui l'operatore ha verificato lo stato dell'endpoint.
+ `Last Modified Time`: l'ultima volta in cui l'endpoint è stato modificato.
+ `Model Names`: coppia chiave-valore di nomi di HostingDeployment modelli per nomi di modelli SageMaker AI.
### Richiamo dell'endpoint
\
--body $(seq 784 | xargs echo | sed 's/ /,/g') \
>(cat) \
--content-type text/csv > /dev/null
```
Ad esempio, se la Regione è `us-east-2` e il nome di configurazione dell'endpoint è `host-xgboost-f56b6b280d7511ea824b129926example`, il comando seguente richiamerà l'endpoint:
```
aws sagemaker-runtime invoke-endpoint \
--region us-east-2 \
--endpoint-name host-xgboost-f56b6b280d7511ea824b1299example \
--body $(seq 784 | xargs echo | sed 's/ /,/g') \
>(cat) \
--content-type text/csv > /dev/null
4.95847082138
```
Di seguito si riporta la previsione `4.95847082138` tratta dal modello per i dati fittizi.
### Aggiorna HostingDeployment
:role/service-role/
...
processingOutputConfig:
outputs:
...
s3Output:
s3Uri: s3:///mnist_kmeans_example/output/
...
processingInputs:
...
s3Input:
s3Uri: s3:///mnist_kmeans_example/processing_code/kmeans_preprocessing.py
```
`sagemaker-execution-role`Devono disporre delle autorizzazioni affinché l' SageMaker IA possa accedere al tuo bucket S3, ad Amazon CloudWatch e ad altri servizi per tuo conto. [Per ulteriori informazioni sulla creazione di un ruolo di esecuzione, consulta SageMaker AI Roles.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html#sagemaker-roles-createtrainingjob-perms)
1. Applica il file YAML usando uno dei comandi seguenti.
Per l'installazione nell’ambito del cluster:
```
kubectl apply -f kmeans-mnist-processingjob.yaml
```
Per l'installazione nell’ambito dello spazio dei nomi:
```
kubectl apply -f kmeans-mnist-processingjob.yaml -n
```
### Elenco ProcessingJobs
kmeans-mnist-processing
```
L'aspetto dell'output sarà simile al seguente:
```
NAME STATUS CREATION-TIME SAGEMAKER-JOB-NAME
kmeans-mnist-processing InProgress 2020-09-22T21:13:25Z kmeans-mnist-processing-7410ed52fd1811eab19a165ae9f9e385
```
L'output elenca tutti i processi, indipendentemente dal loro stato. Per rimuovere un processo dall'elenco, consulta [Eliminazione di un processo di elaborazione](https://docs.aws.amazon.com/sagemaker/latest/dg/kubernetes-processing-job-operator.html#kubernetes-processing-job-delete).
**ProcessingJob Stato**
+ `SynchronizingK8sJobWithSageMaker`: il processo viene innanzitutto trasmesso al cluster. L'operatore ha ricevuto la richiesta e si sta preparando per creare il processo di elaborazione.
+ `Reconciling`: l'operatore sta inizializzando o ripristinando errori transitori, insieme ad altri. Se il processo di elaborazione rimane in questo stato, utilizza il comando `kubectl` `describe` per visualizzare il motivo nel campo `Additional`.
+ `InProgress | Completed | Failed | Stopping | Stopped`— Stato del SageMaker processo di elaborazione. Per ulteriori informazioni, consulta [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html#sagemaker-DescribeProcessingJob-response-ProcessingJobStatus).
+ `Error`: l'operatore non può eseguire il ripristino mediante riconciliazione.
I lavori completati, interrotti o non riusciti non comportano ulteriori addebiti per le risorse di SageMaker intelligenza artificiale.
### Descrivi un ProcessingJob
```
L'aspetto dell'output del processo di elaborazione sarà simile al seguente.
```
$ kubectl describe ProcessingJob kmeans-mnist-processing
Name: kmeans-mnist-processing
Namespace: default
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"sagemaker.aws.amazon.com/v1","kind":"ProcessingJob","metadata":{"annotations":{},"name":"kmeans-mnist-processing",...
API Version: sagemaker.aws.amazon.com/v1
Kind: ProcessingJob
Metadata:
Creation Timestamp: 2020-09-22T21:13:25Z
Finalizers:
sagemaker-operator-finalizer
Generation: 2
Resource Version: 21746658
Self Link: /apis/sagemaker.aws.amazon.com/v1/namespaces/default/processingjobs/kmeans-mnist-processing
UID: 7410ed52-fd18-11ea-b19a-165ae9f9e385
Spec:
App Specification:
Container Entrypoint:
python
/opt/ml/processing/code/kmeans_preprocessing.py
Image Uri: 763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-training:1.5.0-cpu-py36-ubuntu16.04
Environment:
Name: MYVAR
Value: my_value
Name: MYVAR2
Value: my_value2
Network Config:
Processing Inputs:
Input Name: mnist_tar
s3Input:
Local Path: /opt/ml/processing/input
s3DataType: S3Prefix
s3InputMode: File
s3Uri: s3://-us-west-2/algorithms/kmeans/mnist/mnist.pkl.gz
Input Name: source_code
s3Input:
Local Path: /opt/ml/processing/code
s3DataType: S3Prefix
s3InputMode: File
s3Uri: s3:///mnist_kmeans_example/processing_code/kmeans_preprocessing.py
Processing Output Config:
Outputs:
Output Name: train_data
s3Output:
Local Path: /opt/ml/processing/output_train/
s3UploadMode: EndOfJob
s3Uri: s3:///mnist_kmeans_example/output/
Output Name: test_data
s3Output:
Local Path: /opt/ml/processing/output_test/
s3UploadMode: EndOfJob
s3Uri: s3:///mnist_kmeans_example/output/
Output Name: valid_data
s3Output:
Local Path: /opt/ml/processing/output_valid/
s3UploadMode: EndOfJob
s3Uri: s3:///mnist_kmeans_example/output/
Processing Resources:
Cluster Config:
Instance Count: 1
Instance Type: ml.m5.xlarge
Volume Size In GB: 20
Region: us-west-2
Role Arn: arn:aws:iam:::role/m-sagemaker-role
Stopping Condition:
Max Runtime In Seconds: 1800
Tags:
Key: tagKey
Value: tagValue
Status:
Cloud Watch Log URL: https://us-west-2.console.aws.amazon.com/cloudwatch/home?region=us-west-2#logStream:group=/aws/sagemaker/ProcessingJobs;prefix=kmeans-mnist-processing-7410ed52fd1811eab19a165ae9f9e385;streamFilter=typeLogStreamPrefix
Last Check Time: 2020-09-22T21:14:29Z
Processing Job Status: InProgress
Sage Maker Processing Job Name: kmeans-mnist-processing-7410ed52fd1811eab19a165ae9f9e385
Events:
```
### Eliminare un ProcessingJob
```
L'aspetto dell'output del processo di elaborazione sarà simile al seguente.
```
processingjob.sagemaker.aws.amazon.com "kmeans-mnist-processing" deleted
```
**Nota**
SageMaker L'IA non elimina il processo di elaborazione. I lavori interrotti continuano a essere visualizzati nella console SageMaker AI. Il `delete` comando impiega alcuni minuti per ripulire le risorse dall' SageMaker IA.
## HostingAutoscalingPolicy (HAP) Operatore
```
#### Esempio 2: applicazione di una metrica personalizzata a una singola variante di endpoint
```
#### Esempio 3: applicazione di una policy di scalabilità a più endpoint e varianti
```
#### Considerazioni relative a più endpoint e HostingAutoscalingPolicies varianti
```
L'aspetto dell'output sarà simile al seguente:
```
NAME STATUS CREATION-TIME
hap-predefined Created 2021-07-13T21:32:21Z
```
Usa il seguente comando per controllare lo stato del tuo HostingAutoscalingPolicy (HAP).
```
kubectl get hap
```
Viene restituito uno dei seguenti valori:
+ `Reconciling`: alcuni tipi di errori mostrano lo stato `Reconciling` anziché `Error`. Ne sono un esempio gli errori lato server e gli endpoint con stato `Creating` o `Updating`. Controlla il campo `Additional` dello stato o dei registri dell'operatore per ulteriori dettagli.
+ `Created`
+ `Error`
**Per visualizzare l'endpoint di scalabilità automatica a cui hai applicato la policy:**
1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Nel pannello laterale sinistro, espandi **Inferenza**.
1. Scegli **Endpoint**.
1. Seleziona il nome dell'endpoint di interesse.
1. Scorri fino alla sezione **Impostazioni di configurazione degli endpoint**.
### Descrivi un HostingAutoscalingPolicy
```
### Aggiorna un HostingAutoscalingPolicy
```
Questo comando elimina la policy di scalabilità e annulla la registrazione della destinazione di scalabilità da Kubernetes. Questo comando restituisce il seguente output:
```
hostingautoscalingpolicies.sagemaker.aws.amazon.com "hap-predefined" deleted
```
### Aggiorna o elimina un endpoint con un HostingAutoscalingPolicy
` con un nome da assegnare al cluster.
```
eksctl create cluster --name --region us-east-1 --auto-kubeconfig --timeout=50m --managed --nodes=1
```
1. Una volta completata la creazione del cluster, assicurati di poter accedere al cluster elencandone i nodi.
```
kubectl get nodes
```
1. Assicurati che il contesto `kubectl` corrente punti al cluster con il comando seguente. Il contesto corrente è contrassegnato da un asterisco (\$1) nell'output.
```
kubectl config get-contexts
CURRENT NAME CLUSTER
* @.us-east-1.eksctl.io .us-east-1.eksctl.io
```
1. Se il cluster desiderato non è configurato come quello attualmente predefinito, aggiorna il cluster predefinito con il seguente comando.
```
aws eks update-kubeconfig --name --region us-east-1
```
#### Installazione di Kubeflow Pipelines
8888/TCP,8887/TCP 2d
service/ml-pipeline-ui ClusterIP 10.100.38.71 80/TCP 2d
service/ml-pipeline-visualizationserver ClusterIP 10.100.61.47 8888/TCP 2d
deployment.apps/ml-pipeline 1/1 1 1 2d
deployment.apps/ml-pipeline-persistenceagent 1/1 1 1 2d
deployment.apps/ml-pipeline-scheduledworkflow 1/1 1 1 2d
deployment.apps/ml-pipeline-ui 1/1 1 1 2d
deployment.apps/ml-pipeline-viewer-crd 1/1 1 1 2d
deployment.apps/ml-pipeline-visualizationserver 1/1 1 1 2d
replicaset.apps/ml-pipeline-6b88c67994 1 1 1 2d
replicaset.apps/ml-pipeline-persistenceagent-64d74dfdbf 1 1 1 2d
replicaset.apps/ml-pipeline-scheduledworkflow-65bdf46db7 1 1 1 2d
replicaset.apps/ml-pipeline-ui-66cc4cffb6 1 1 1 2d
replicaset.apps/ml-pipeline-viewer-crd-6db65ccc4 1 1 1 2d
replicaset.apps/ml-pipeline-visualizationserver-9c47576f4 1 1 1 2d
```
## Configura le autorizzazioni della pipeline per accedere all'IA SageMaker
Per eseguire la versione 1 di SageMaker AI Components per Kubeflow Pipelines, i pod Kubeflow Pipeline devono accedere all'IA. SageMaker
**Importante**
Segui questa sezione se stai utilizzando la versione completa di Kubeflow on deployment o Kubeflow Pilepines standalone. AWS
Per creare un ruolo di esecuzione IAM che consenta ai pod della pipeline Kubeflow di accedere all'intelligenza artificiale, segui questi passaggi: SageMaker
1. Esporta il nome del cluster (ad es. *my-cluster-name*) e la regione del cluster (ad es. *us-east-1*).
```
export CLUSTER_NAME=my-cluster-name
export CLUSTER_REGION=us-east-1
```
1. Esporta lo spazio dei nomi e il nome dell'account di servizio in base all'installazione.
+ Per l' AWS installazione completa di Kubeflow, esporta il tuo profilo `namespace` (ad esempio *kubeflow-user-example-com*) e l'editor *predefinito* come account di servizio.
```
export NAMESPACE=kubeflow-user-example-com
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=default-editor
```
+ Per l’implementazione standalone di Pipelines, esporta *kubeflow* come `namespace` e *pipeline-runner* come account di servizio.
```
export NAMESPACE=kubeflow
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=pipeline-runner
```
1. Crea un [provider di identità OIDC IAM per il cluster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) con il comando seguente.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} --approve
```
1. Crea un ruolo di esecuzione IAM per i pod KFP per accedere ai servizi (AI,). AWS SageMaker CloudWatch
```
eksctl create iamserviceaccount \
--name ${KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT} \
--namespace ${NAMESPACE} --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} \
--attach-policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess \
--attach-policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess \
--override-existing-serviceaccounts \
--approve
```
[Una volta configurate le autorizzazioni della pipeline per accedere alla versione 1 di SageMaker AI Components, segui la guida ai componenti SageMaker AI per le pipeline Kubeflow sulla documentazione di Kubeflow. AWS](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/)
## Accesso all'interfaccia utente KFP (dashboard Kubeflow)
80/TCP 2d22h
```
1. Esegui il comando riportato di seguito per configurare l’inoltro delle porte verso il servizio dell'interfaccia utente KFP. In questo modo, l'interfaccia utente KFP viene inoltrata alla porta 8080 sul nodo gateway, consentendo di accedere all'interfaccia utente KFP dal browser.
```
kubectl port-forward -n kubeflow service/ml-pipeline-ui 8080:80
```
L’inoltro delle porte dal computer remoto si interrompe in caso di inattività. Esegui nuovamente questo comando se il dashboard non è in grado di ricevere registri o aggiornamenti. Se i comandi restituiscono un errore, assicurati che non vi siano processi in esecuzione sulla porta che stai cercando di utilizzare.
#### Accesso al servizio dell’interfaccia utente KFP
` con l'indirizzo IP dell'istanza trovato sulla console Amazon EC2. Puoi anche usare il DNS pubblico. Sostituisci `` con il percorso della chiave pem utilizzata per accedere al nodo gateway.
```
public_DNS_address=
key=
on Ubuntu:
ssh -i ${key} -L 9000:localhost:8080 ubuntu@${public_DNS_address}
or on Amazon Linux:
ssh -i ${key} -L 9000:localhost:8080 ec2-user@${public_DNS_address}
```
1. Accedi al dashboard del tuo browser nel browser.
```
http://localhost:9000
```
1. Scegli **Pipelines** per accedere all'interfaccia utente di KFP.
#### (Facoltativo) Concedi alle istanze di notebook SageMaker AI l'accesso ad Amazon EKS ed esegui pipeline KFP dal tuo notebook.
` con il nome dell’istanza.
```
aws sagemaker describe-notebook-instance --notebook-instance-name --region --output text --query 'RoleArn'
```
Questo comando restituisce l'ARN del ruolo IAM nel formato `arn:aws:iam:::role/`. Annota l'ARN.
1. Esegui questo comando per allegare le seguenti politiche (AmazonSageMakerFullAccess, Amazon EKSWorkerNodePolicy, AmazonS3FullAccess) a questo ruolo IAM. Nell’ARN, sostituisci `` con ``.
```
aws iam attach-role-policy --role-name --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
aws iam attach-role-policy --role-name --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
aws iam attach-role-policy --role-name --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
```
1. I cluster Amazon EKS utilizzano i ruoli IAM per controllare l'accesso al cluster. Le regole sono implementate in una mappa di configurazione denominata `aws-auth`. `eksctl` fornisce comandi per leggere e modificare la mappa di configurazione `aws-auth`. Solo gli utenti che hanno accesso al cluster possono modificare questa mappa di configurazione.
`system:masters` rappresenta uno dei gruppi di utenti predefiniti con privilegi per il cluster. Aggiungi il tuo utente a questo gruppo o crea un gruppo con autorizzazioni più restrittive.
1. Collega il ruolo al cluster eseguendo il seguente comando. Sostituisci `` con l'ARN del ruolo IAM. `` può essere qualsiasi nome utente univoco.
```
eksctl create iamidentitymapping \
--cluster \
--arn \
--group system:masters \
--username \
--region
```
1. Apri un notebook Jupyter sulla tua istanza SageMaker AI ed esegui il comando seguente per assicurarti che abbia accesso al cluster.
```
aws eks --region update-kubeconfig --name
kubectl -n kubeflow get all | grep pipeline
```
# Usa componenti AI SageMaker
` il nome del bucket Amazon S3.
```
aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3:///mnist_kmeans_example/processing_code/kmeans_preprocessing.py
```
### Compilazione e implementazione della pipeline
` con il percorso della pipeline e `` con la posizione in cui desideri che si trovi il file tar.gz.
```
dsl-compile --py --output
```
#### Caricamento ed esecuzione della pipeline utilizzando la CLI KFP
```
L'aspetto dell'output sarà simile al seguente. Prendi nota della pipeline `ID`.
```
Pipeline 29c3ff21-49f5-4dfe-94f6-618c0e2420fe has been submitted
Pipeline Details
------------------
ID 29c3ff21-49f5-4dfe-94f6-618c0e2420fe
Name sm-pipeline
Description
Uploaded at 2020-04-30T20:22:39+00:00
...
...
```
1. Crea un’esecuzione utilizzando il comando seguente. Il comando di esecuzione della CLI di KFP attualmente non supporta la specifica dei parametri di input durante la creazione dell'esecuzione. È necessario aggiornare i parametri nel file della AWS SDK per Python (Boto3) pipeline prima della compilazione. Sostituisci `` e `` con qualsiasi nome. Sostituisci `` con l'ID della pipeline inviata. Sostituisci `` con l'ARN di `kfp-example-pod-role`. Sostituisci `` con il nome del bucket Amazon S3 creato.
```
kfp run submit --experiment-name --run-name --pipeline-id role_arn="" bucket_name=""
```
È inoltre possibile inviare direttamente un'esecuzione utilizzando il pacchetto di pipeline compilato creato come output del comando `dsl-compile`.
```
kfp run submit --experiment-name --run-name --package-file role_arn="" bucket_name=""
```
L'aspetto dell'output deve essere simile al seguente:
```
Creating experiment aws.
Run 95084a2c-f18d-4b77-a9da-eba00bf01e63 is submitted
+--------------------------------------+--------+----------+---------------------------+
| run id | name | status | created at |
+======================================+========+==========+===========================+
| 95084a2c-f18d-4b77-a9da-eba00bf01e63 | sm-job | | 2020-04-30T20:36:41+00:00 |
+--------------------------------------+--------+----------+---------------------------+
```
1. Accedi all'interfaccia utente per verificare lo stato di avanzamento del processo.
#### Caricamento ed esecuzione della pipeline utilizzando l’UI di KFP
./sagemaker-invoke.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint"
],
"Resource": "*"
}
]
}
EoF
```
1. Collega la policy al ruolo IAM del nodo client.
Eseguire il seguente comando seguente. Sostituisci `` con il nome del ruolo IAM. Sostituisci `` con il percorso del file di policy creato.
```
aws iam put-role-policy --role-name --policy-name sagemaker-invoke-for-worker --policy-document file://
```
#### Esecuzione di previsioni
'
region = boto3.Session().region_name
# S3 bucket where the original mnist data is downloaded and stored
downloaded_data_bucket = f"jumpstart-cache-prod-{region}"
downloaded_data_prefix = "1p-notebooks-datasets/mnist"
# Download the dataset
s3 = boto3.client("s3")
s3.download_file(downloaded_data_bucket, f"{downloaded_data_prefix}/mnist.pkl.gz", "mnist.pkl.gz")
# Load the dataset
with gzip.open('mnist.pkl.gz', 'rb') as f:
train_set, valid_set, test_set = pickle.load(f, encoding='latin1')
# Simple function to create a csv from our numpy array
def np2csv(arr):
csv = io.BytesIO()
numpy.savetxt(csv, arr, delimiter=',', fmt='%g')
return csv.getvalue().decode().rstrip()
runtime = boto3.Session(region).client('sagemaker-runtime')
payload = np2csv(train_set[0][30:31])
response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME,
ContentType='text/csv',
Body=payload)
result = json.loads(response['Body'].read().decode())
print(result)
```
1. Esegui il AWS SDK per Python (Boto3) file come segue:
```
python mnist-predictions.py
```
### Visualizzazione di risultati e registri
```
### Rimozione
```
1. Utilizzando il tuo AWS account, accedi al servizio SageMaker AI. Interrompi manualmente tutti i processi di addestramento, trasformazione in batch e HPO. Elimina modelli, bucket di dati ed endpoint per evitare che influiscano sulle tue risorse. L'interruzione delle operazioni della pipeline non interrompe i lavori nell' SageMaker intelligenza artificiale.
# SageMaker Lavori su notebook
**.
1. Seleziona **Fatto**.
# Aggiornamento dei dettagli del job di addestramento (Studio)
**.
1. Seleziona **Fatto**.
# Aggiornamento di un processo di valutazione (Studio)
--resource-policy "{\"Version\":\"2012-10-17\", \"Statement\":[{\"Sid\":
\"ExampleResourcePolicy\",\"Effect\":\"Allow\",\"Principal\":,
\"Action\":[\"sagemaker:DescribeModelPackage\",
\"sagemaker:ListModelPackages\",\"sagemaker:DescribeModelPackageGroup\"],
\"Resource\":[\",\"
\"arn:aws:sagemaker:::model-package/
/*\"]}]}"
```
**Nota**
Puoi collegare diverse combinazioni di azioni alla policy delle risorse. Per le policy personalizzate, l’autorizzazione creata deve essere promossa dal proprietario del gruppo di pacchetti di modelli e solo le entità a cui sono collegate autorizzazioni promosse sono rilevabili. Le condivisioni di risorse non promovibili non possono essere rese rilevabili o gestite tramite AWS RAM.
1. Per verificare che abbia AWS RAM creato l'ARN della condivisione di risorse, utilizzare il seguente comando:
```
aws ram get-resource-share-associations --association-type resource --resource-arn
```
La risposta contiene il comando *resource-share-arn* per l'entità.
1. Per verificare se l’autorizzazione per la policy collegata è una policy gestita o personalizzata, utilizza il comando seguente:
```
aws ram list-resource-share-permissions --resource-share-arn
```
Il campo `featureSet` può assumere i valori `CREATED_FROM_POLICY` o `STANDARD`, che sono definiti come descritto di seguito:
+ `STANDARD`: l’autorizzazione esiste già.
+ `CREATED_FROM_POLICY`: l’autorizzazione deve essere promossa affinché l’entità sia rilevabile. Per ulteriori informazioni, consulta [Promozione dell’autorizzazione e della condivisione di risorse](model-registry-ram-promote.md).
1. Accetta l’invito alla condivisione di risorse nell’account consumer di modelli.
1. Il consumer del gruppo di pacchetti di modelli accetta l’invito alla condivisione di risorse. Per visualizzare tutti gli inviti relativi alle risorse, utilizza il comando seguente:
```
aws ram get-resource-share-invitations
```
Identifica le richieste con stato `PENDING` e includi l’ID dell’account del proprietario.
1. Accetta l’invito alla condivisione di risorse dal proprietario del modello utilizzando il comando seguente:
```
aws ram accept-resource-share-invitation --resource-share-invitation-arn
```
------
#### [ AWS RAM console ]
1. Accedi alla [console AWS RAM](https://console.aws.amazon.com/ram/home).
1. Completa la procedura seguente per creare una condivisione di risorse dall’account del proprietario del gruppo di pacchetti di modelli.
1. Completa la procedura seguente per specificare i dettagli della condivisione di risorse.
1. Nel campo **Nome**, aggiungi un nome univoco per la tua risorsa.
1. Nella scheda **Risorse**, scegli il menu a discesa e seleziona **SageMaker AI Model Package Groups**.
1. Seleziona la casella di controllo dell’ARN della condivisione di risorse del gruppo di pacchetti di modelli.
1. Nella scheda **Seleziona risorse**, seleziona la casella di controllo della condivisione di risorse del gruppo di pacchetti di modelli.
1. Nella scheda **Tag**, aggiungi coppie chiave-valore per i tag da aggiungere alla tua condivisione di risorse.
1. Scegli **Next (Successivo)**.
1. Completa la procedura seguente per associare le autorizzazioni gestite alla condivisione di risorse.
1. Se utilizzi un’autorizzazione gestita, scegline una dal menu a discesa **Autorizzazioni gestite**.
1. Se utilizzi un’autorizzazione personalizzata, scegli **Autorizzazione gestita dal cliente**. In questo caso, il gruppo di pacchetti di modelli non è immediatamente rilevabile. Dopo aver creato la condivisione di risorse, devi promuovere l’autorizzazione e la policy delle risorse. Per informazioni su come promuovere le autorizzazioni e le condivisioni di risorse, consulta [Promozione dell’autorizzazione e della condivisione di risorse](model-registry-ram-promote.md). Per ulteriori informazioni su come collegare le autorizzazioni personalizzate, consulta [Creazione e utilizzo di autorizzazioni gestite dal cliente in AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/create-customer-managed-permissions.html).
1. Scegli **Next (Successivo)**.
1. Completa la procedura seguente per concedere l’accesso ai principali.
1. Scegli **Consenti la condivisione con chiunque** per consentire la condivisione con account esterni all’organizzazione oppure scegli **Consenti la condivisione solo all’interno dell’organizzazione**.
1. Nel menu a discesa **Seleziona il tipo di principale**, aggiungi i tipi e gli ID dei principali da aggiungere.
1. Aggiungi e seleziona i principali scelti per la condivisione.
1. Scegli **Next (Successivo)**.
1. Controlla la configurazione della condivisione visualizzata, quindi scegli **Crea condivisione di risorse**.
1. Accetta l’invito alla condivisione di risorse dall’account consumer. Dopo che il proprietario di modelli ha creato la condivisione di risorse e le associazioni di principali, gli account consumer di risorse specificati ricevono un invito a partecipare alla condivisione di risorse. Gli account consumer di risorse possono visualizzare e accettare gli inviti nella pagina [Shared with me: Resource shares](https://console.aws.amazon.com/ram/home#SharedResourceShares:) nella console AWS RAM . Per ulteriori informazioni sull'accettazione e la visualizzazione delle risorse in AWS RAM, vedi [Accedere alle AWS risorse condivise con te](https://docs.aws.amazon.com//ram/latest/userguide/working-with-shared.html).
------
# Visualizzazione dei gruppi di pacchetti di modelli condivisi
--principals
```
Per eliminare una condivisione di risorse, utilizzate il comando seguente: [delete-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/delete-resource-share.html)
```
aws ram delete-resource-share --resource-share-arn
```
## AWS RAM console
```
1. Promuovi la condivisione di risorse con il comando seguente:
```
aws ram promote-resource-share-created-from-policy --resource-share-arn
```
Se visualizzi l’errore `OperationNotPermittedException` durante l’esecuzione delle fasi precedenti, l’entità non è rilevabile ma è accessibile. Ad esempio, se il proprietario delle risorse associa una policy delle risorse a un principale di assunzione del ruolo, ad esempio `“Principal”: {“AWS”: “arn:aws:iam::3333333333:role/Role-1”}`, o se la policy delle risorse consente `“Action”: “*”`, il gruppo di pacchetti di modelli associato non è né promosso né rilevabile.
# Visualizzazione della cronologia di implementazione di un modello
```
Quindi usa la AWS console, Python o le operazioni [CreateProject](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProject.html)e [UpdateProject](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateProject.html)API per creare o aggiornare un SageMaker progetto dai modelli all'interno del bucket S3.
------
#### [ Studio ]
**Creazione di un progetto**
1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Apri la console SageMaker Studio seguendo le istruzioni in [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. Nel riquadro di navigazione a sinistra, scegli **Implementazioni**, **Progetti**, **Crea** progetto.
1. Scegli **Modelli di organizzazione** e poi **Modelli S3** per vedere i modelli disponibili. Se non vedi il modello che ti aspetti, avvisa il tuo amministratore.
1. Scegli il modello che desideri utilizzare, quindi scegli **Avanti**.
1. Inserisci un nome per il progetto, una descrizione opzionale e gli altri campi obbligatori. Al termine, selezionare **Create (Crea)**.
**Aggiorna un progetto**
1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Apri la console SageMaker Studio seguendo le istruzioni in [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
1. Scegli il progetto che desideri aggiornare. Scegli **Azioni**, quindi scegli **Aggiorna progetto**.
1. Quando aggiorni un progetto, puoi aggiornare i parametri del modello o l'URL del modello. Al termine, selezionare **Next (Successivo)**.
1. Controlla gli aggiornamenti del progetto nella tabella di riepilogo e scegli **Aggiorna**.
------
#### [ Python Boto3 ]
Dopo aver creato il bucket S3 e caricato i modelli, puoi utilizzare il seguente esempio per creare un SageMaker progetto.
```
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
response = sagemaker_client.create_project(
ProjectName='my-custom-project',
ProjectDescription='SageMaker project with custom CFN template stored in S3',
TemplateProviders=[{
'CfnTemplateProvider': {
'TemplateName': 'CustomProjectTemplate',
'TemplateURL': f'https://.s3.us-west-2.amazonaws.com/custom-project-template.yml',
'Parameters': [
{'Key': 'ParameterKey', 'Value': 'ParameterValue'}
]
}
}]
)
print(f"Project ARN: {response['ProjectArn']}")
```
Per aggiornare un SageMaker progetto, consulta l'esempio seguente.
```
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
response = sagemaker_client.update_project(
ProjectName='my-custom-project',
ProjectDescription='SageMaker project with custom CFN template stored in S3',
TemplateProvidersToUpdate=[{
'CfnTemplateProvider': {
'TemplateName': 'CustomProjectTemplate',
'TemplateURL': f'https://.s3.us-west-2.amazonaws.com/custom-project-template.yml',
'Parameters': [
{'Key': 'ParameterKey', 'Value': 'ParameterValue'}
]
}
}]
)
print(f"Project ARN: {response['ProjectArn']}")
```
------
# Visualizzazione delle risorse di progetto