Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Implementieren MLOps
/*",
"Effect": "Allow"
}
```
## Berechtigungen für Pipeline-Schritte
*
*
PUT
Access-Control-Allow-Origin
```
Das folgende GIF zeigt die Anweisungen in der Amazon S3-Dokumentation zum Hinzufügen einer CORS-Header-Richtlinie mithilfe der Amazon S3-Konsole.
![\[Gif zum Hinzufügen einer CORS-Header-Richtlinie mit der Amazon-S3-Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Anpassen der Zugriffsverwaltung für Pipelines-Aufträge
---`
| Feld | Definition |
| --- | --- |
| Pipelines | Eine statische Zeichenfolge wird immer vorangestellt. Diese Zeichenfolge identifiziert den Pipeline-Orchestrierungsdienst als Quelle des Jobs. |
| executionId | Ein zufälliger Puffer für die laufende Instance der Pipeline. |
| stepNamePrefix | Der vom Benutzer angegebene Schrittname (im `name` Argument des Pipeline-Schritts angegeben), begrenzt auf die ersten 20 Zeichen. |
| entityToken | Ein zufälliges Token, um die Idempotenz der Schrittentität sicherzustellen. |
| failureCount | Die aktuelle Anzahl der Versuche, den Job abzuschließen. |
In diesem Fall wird dem Jobnamen kein benutzerdefiniertes Präfix vorangestellt, und die entsprechende IAM-Richtlinie muss mit dieser Zeichenfolge übereinstimmen.
Für Benutzer, die das Job-Präfix aktivieren, hat der zugrunde liegende Jobname die folgende Form, wobei das benutzerdefinierte Präfix wie folgt angegeben ist: `MyBaseJobName`
**-**-**-**
Das benutzerdefinierte Präfix ersetzt die statische `pipelines` Zeichenfolge, sodass Sie die Auswahl der Benutzer einschränken können, die den SageMaker KI-Job als Teil einer Pipeline ausführen können.
**Längenbeschränkungen für das Präfix**
Die Auftragsnamen haben interne Längenbeschränkungen, die für einzelne Pipeline-Schritte spezifisch sind. Diese Einschränkung begrenzt auch die Länge des zulässigen Präfixes. Die Anforderungen an die Präfixlänge lauten wie folgt:
| Pipeline-Schritt | Länge des Präfixes |
| --- | --- |
| `[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 |
### Wenden Sie Job-Präfixe auf eine IAM-Richtlinie an
= (
name="",
default_value=
)
```
Das folgende Beispiel zeigt eine Beispielimplementierung eines Parameters.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Sie übergeben den Parameter bei der Erstellung Ihrer Pipeline wie im folgenden Beispiel dargestellt.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
Sie können auch einen Parameterwert, der vom Standardwert abweicht, an eine Pipeline-Ausführung übergeben, wie im folgenden Beispiel gezeigt.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Sie können Parameter mit SageMaker Python-SDK-Funktionen wie manipulieren`[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)`. Weitere Informationen zu Parametern finden Sie unter [ SageMaker Pipeline-Parameter](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters).
Bekannte Einschränkungen von Pipeline-Parametern finden Sie unter *[Einschränkungen — Parametrisierung](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* im [Amazon SageMaker ](https://sagemaker.readthedocs.io/en/stable) Python SDK.
# Pipelines-Schritte
`
1. Für komprimierte Ordner-Uploads müssen relative Pfade zu Ihrem Code angegeben werden, und Sie können optional Pfade zu einer `requirements.txt` Datei oder einem Initialisierungsskript innerhalb des komprimierten Ordners angeben.
1. Wenn die Arbeitsfläche einen Schritt enthält, der unmittelbar vor dem von Ihnen hinzugefügten Schritt „**Code ausführen**“ steht, klicken Sie auf den Schritt und ziehen Sie den Cursor von diesem Schritt zum Schritt „**Code ausführen**“, um eine Kante zu erstellen.
1. Wenn die Zeichenfläche einen Schritt enthält, der unmittelbar auf den Schritt „**Code ausführen**“ folgt, klicken Sie auf den Schritt „Code ausführen“ und ziehen Sie den Cursor vom Schritt „**Code ausführen**“ zu dem Schritt, um eine Kante zu erstellen. Ausgaben von **Execute-Codeschritten** können für Python-Funktionen referenziert werden.
## Verarbeitungsschritt
,
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")
)
```
**Übergeben Sie Laufzeitparameter**
Das folgende Beispiel zeigt, wie Laufzeitparameter von einem PySpark Prozessor an einen übergeben `ProcessingStep` werden.
```
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,
)
```
Weitere Informationen zu den Anforderungen für Verarbeitungsschritte finden Sie unter [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)Dokumentation. Ein ausführliches Beispiel finden Sie im [Beispielnotizbuch 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). Weitere Informationen finden Sie im Abschnitt *Verarbeitungsschritt für Feature Engineering definieren*.
------
## Schritt des Trainings
",
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,
)
```
**Holen Sie sich die beste Modellversion**
Der AutoML-Schritt trainiert automatisch mehrere Modellkandidaten. Rufen Sie das Modell mit der besten Zielmetrik aus dem AutoML-Auftrag ab, indem Sie die `get_best_auto_ml_model`-Methode wie folgt verwenden. Sie müssen auch ein IAM verwenden, `role` um auf Modellartefakte zuzugreifen.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Weitere Informationen finden Sie im [AutoML-Schritt](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) im SageMaker Python-SDK.
## Modellschritt
* Instanzen wie nötig anhängen können, um die gewünschte verschachtelte Eigenschaft in der Datei zu erreichen. [Weitere Informationen zur JsonPath Notation finden Sie im JsonPath Repo.](https://github.com/json-path/JsonPath)
```
.properties..
```
Im Folgenden wird gezeigt, wie ein Amazon-S3-Bucket mithilfe der `ProcessingOutputConfig` Eigenschaft eines Verarbeitungsschritts angegeben wird.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Um die Datenabhängigkeit zu erstellen, übergeben Sie den Bucket wie folgt an einen Trainingsschritt.
```
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
))
)
```
Informationen dazu, welche Eigenschaften für jeden Schritttyp bei der Erstellung von Datenabhängigkeiten referenzierbar sind, finden Sie unter *[Datenabhängigkeit — Eigenschaftsreferenz](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
## Benutzerdefinierte Abhängigkeit zwischen Schritten
",
steps=[step_train_result],
sagemaker_session=,
)
```
Wenn zwischen den Schritten keine Daten oder benutzerdefinierten Abhängigkeiten bestehen und Sie mehrere Schritte parallel ausführen, hat das Pipeline-Diagramm mehr als einen Blattknoten. Übergeben Sie all diese Blattknoten in einer Liste an das `steps` Argument in Ihrer Pipeline-Definition, wie im folgenden Beispiel gezeigt:
```
@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,
)
```
Wenn die Pipeline läuft, laufen beide Schritte parallel.
Sie übergeben nur die Blattknoten des Diagramms an die Pipeline, da die Blattknoten Informationen über alle vorherigen Schritte enthalten, die durch Daten oder benutzerdefinierte Abhängigkeiten definiert wurden. Beim Kompilieren der Pipeline leitet SageMaker KI auch von allen nachfolgenden Schritten ab, die den Pipeline-Graphen bilden, und fügt jeden von ihnen als separaten Schritt zur Pipeline hinzu.
## Erstellen Sie eine 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()
```
# Konfigurieren Ihrer Pipeline
", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Sie können eine Pipeline-Variable nicht in einem anderen Objekt verschachteln und an eine `@step` Funktion übergeben. Das folgende Beispiel erzeugt einen Fehler:
```
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
```
+ Da die Ein- und Ausgaben einer Funktion serialisiert sind, gibt es Einschränkungen hinsichtlich der Art der Daten, die als Eingabe oder Ausgabe von einer Funktion übergeben werden können. Weitere Informationen finden Sie im Abschnitt *Datenserialisierung und Deserialisierung* von[Aufrufen einer Remote-Funktion](train-remote-decorator-invocation.md). Die gleichen Einschränkungen gelten für `@step`-dekorierte Funktionen.
+ Objekte, die einen Boto-Client enthalten, können nicht serialisiert werden. Daher können Sie solche Objekte nicht als Eingabe an eine mit `@step`-dekorierte Funktion übergeben oder als Ausgabe von einer solchen Funktion erhalten. Beispielsweise `Processor` können SageMaker Python-SDK-Clientklassen wie `Estimator``Predictor`, und nicht serialisiert werden.
## Funktionsimporte
",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Wenn Sie `JsonGet` mit einem Amazon-S3-Pfad im Bedingungsschritt verwenden, müssen Sie explizit eine Abhängigkeit zwischen dem Bedingungsschritt und dem Schritt, der die JSON-Ausgabe generiert, hinzufügen. Im folgenden Beispiel wird der Bedingungsschritt mit einer Abhängigkeit vom Verarbeitungsschritt erstellt:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Übergeben Sie Daten mit Eigenschaftendateien zwischen Schritten
= PropertyFile(
name="",
output_name="",
path=""
)
```
Wenn Sie Ihre `ProcessingStep` Instance erstellen, fügen Sie den `property_files` Parameter hinzu, um alle Parameterdateien aufzulisten, die der Amazon SageMaker Pipelines-Service indizieren muss. Dadurch wird die Eigenschaftendatei für die spätere Verwendung gespeichert.
```
property_files=[]
```
Um Ihre Eigenschaftsdatei in einem Bedingungsschritt zu verwenden, fügen Sie `property_file` zu der Bedingung hinzu, die Sie an Ihren Bedingungsschritt übergeben, wie im folgenden Beispiel gezeigt, um die JSON-Datei mit dem Parameter `json_path` nach der gewünschten Eigenschaft abzufragen.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Ausführlichere Beispiele finden Sie unter *[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Zwischenspeichern von Pipeline-Schritten
"
}
}
```
Das `Enabled` Feld gibt an, ob das Caching für den jeweiligen Schritt aktiviert ist. Sie können das Feld auf setzen`true`, was SageMaker KI anweist, zu versuchen, eine vorherige Ausführung des Schritts mit denselben Attributen zu finden. Oder Sie können das Feld auf setzen`false`, wodurch die SageMaker KI angewiesen wird, den Schritt bei jeder Ausführung der Pipeline auszuführen. `ExpireAfter`ist eine Zeichenfolge im [ISO 8601-Dauerformat](https://en.wikipedia.org/wiki/ISO_8601#Durations), die den Timeout-Zeitraum definiert. Bei der `ExpireAfter` Dauer kann es sich um einen Wert für ein Jahr, einen Monat, eine Woche, einen Tag, eine Stunde oder eine Minute handeln. Jeder Wert besteht aus einer Zahl, gefolgt von einem Buchstaben, der die Einheit der Dauer angibt. Beispiel:
+ „30d“ = 30 Tage
+ „5y“ = 5 Jahre
+ „T16m“ = 16 Minuten
+ „30DT5h“ = 30 Tage und 5 Stunden.
In der folgenden Diskussion wird das Verfahren zum Aktivieren des Caching für neue oder bereits bestehende Pipelines mithilfe des Amazon SageMaker Python SDK beschrieben.
**Schalten Sie das Caching für neue Pipelines ein**
Initialisieren Sie bei neuen Pipelines eine `CacheConfig` Instance mit `enable_caching=True` und geben Sie sie als Eingabe für Ihren Pipeline-Schritt an. Im folgenden Beispiel wird das Caching mit einem Timeout von 1 Stunde für einen Trainingsschritt aktiviert:
```
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
)
```
**Schalten Sie das Caching für bereits bestehende Pipelines ein**
Um die Zwischenspeicherung für bereits vorhandene, bereits definierte Pipelines zu aktivieren, aktivieren Sie die Eigenschaft `enable_caching` für den Schritt und setzen Sie `expire_after` auf einen Timeout-Wert. Zuletzt aktualisieren Sie die Pipeline mit `pipeline.upsert()` oder `pipeline.update()`. Sobald Sie es erneut ausführen, aktiviert das folgende Codebeispiel das Caching mit einem Timeout von 1 Stunde für einen Trainingsschritt:
```
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()
```
Alternativ können Sie die Cache-Konfiguration aktualisieren, nachdem Sie die (bereits vorhandene) Pipeline definiert haben, sodass ein kontinuierlicher Codelauf möglich ist. Das folgende Codebeispiel demonstriert diese Methode:
```
# 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()
```
Ausführlichere Codebeispiele und eine Diskussion darüber, wie sich Python-SDK-Parameter auf das Caching auswirken, finden Sie unter [Caching-Konfiguration](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#caching-configuration) in der Amazon SageMaker Python SDK-Dokumentation.
# Deaktivieren des Schritt-Caching
"
}
}
```
Beachten Sie, dass das Attribut `ExpireAfter` ignoriert wird, wenn `Enabled` gleich `false` ist.
Um das Caching für einen Pipeline-Schritt mithilfe des Amazon SageMaker Python SDK zu deaktivieren, definieren Sie die Pipeline Ihres Pipeline-Schritts, schalten Sie die `enable_caching` Eigenschaft aus und aktualisieren Sie die Pipeline.
Sobald Sie es erneut ausführen, deaktiviert das folgende Codebeispiel das Caching für einen Trainingsschritt:
```
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()
```
Sie können die `enable_caching` Eigenschaft auch deaktivieren, nachdem Sie die Pipeline bereits definiert haben, sodass ein kontinuierlicher Code ausgeführt werden kann. Das folgende Codebeispiel veranschaulicht diese Lösung:
```
# 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()
```
Ausführlichere Codebeispiele und eine Diskussion darüber, wie sich Python-SDK-Parameter auf das Caching auswirken, finden Sie unter [Caching-Konfiguration](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#caching-configuration) in der Amazon SageMaker Python SDK-Dokumentation.
# Standard-Cache-Schlüsselattribute nach Pipeline-Schritttyp
----event-pattern --description --role-arn --tags
```
+ **Zeitplan**: Ihre Regel wird regelmäßig nach einem bestimmten Zeitplan initiiert. Sie können einen festen Tarif verwenden, der regelmäßig für eine bestimmte Anzahl von Minuten, Stunden oder Wochen initiiert wird. Sie können auch einen Cron-Ausdruck verwenden, um einen detaillierteren Zeitplan zu erstellen, z. B. „jeden ersten Montag im Monat um 8 Uhr“. Der Zeitplan wird für benutzerdefinierte Ereignisse oder Partner-Ereignisse nicht unterstützt. Sie können eine Regel mit Zeitplan mit dem folgenden Befehl erstellen:
```
aws events put-rule --name --schedule-expression --description --role-arn --tags
```
1. Fügen Sie Ziele hinzu, die aufgerufen werden sollen, wenn ein Ereignis Ihrem Ereignismuster entspricht oder wenn der Zeitplan initiiert wird. Sie können bis zu 5 Ziele pro Regel hinzufügen. Für jedes Ziel müssen Sie Folgendes angeben:
+ ARN: Der Ressourcen-ARN Ihrer Pipeline.
+ Rollen-ARN: Der ARN der Rolle EventBridge sollte die Ausführung der Pipeline übernehmen.
+ Parameter: Zu übergebende Amazon SageMaker AI-Pipeline-Parameter.
1. Führen Sie den folgenden Befehl aus, um mithilfe von [put-targets](https://docs.aws.amazon.com/cli/latest/reference/events/put-targets.html) eine Amazon SageMaker AI-Pipeline als Ziel an Ihre Regel zu übergeben:
```
aws events put-targets --rule --event-bus-name --targets "[{\"Id\": , \"Arn\": , \"RoleArn\": , \"SageMakerPipelineParameter\": { \"SageMakerParameterList\": [{\"Name\": , \"Value\": }]} }]"]
```
## Planen Sie eine Pipeline mit dem 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"
)
```
**Anmerkung**
Wenn Sie einen einmaligen Zeitplan erstellen und auf die aktuelle Uhrzeit zugreifen müssen, verwenden Sie `datetime.utcnow()` statt`datetime.now()`. Letzteres speichert den aktuellen Zonenkontext nicht und führt zu einer falschen Zeitangabe EventBridge.
### Hängen Sie den Trigger an Ihre Pipeline an
",
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=)
```
### Beschreiben Sie die aktuellen Auslöser
")
```
### Bereinigungs-Trigger-Ressourcen
"])
```
**Anmerkung**
Beachten Sie die folgenden Einschränkungen, wenn Sie Ihre Trigger löschen:
Die Option zum Löschen der Trigger durch Angabe von Triggernamen ist nur im SageMaker Python-SDK verfügbar. Durch das Löschen der Pipeline in der CLI oder bei einem `DeletePipeline` API-Aufruf werden Ihre Trigger nicht gelöscht. Infolgedessen werden die Trigger verwaist und die SageMaker KI versucht, einen Run für eine nicht existierende Pipeline zu starten.
Wenn Sie eine andere Notebook-Sitzung verwenden oder das Pipeline-Ziel bereits gelöscht haben, bereinigen Sie außerdem verwaiste Zeitpläne über die [Scheduler-CLI oder EventBridge -Konsole](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/scheduler/delete-schedule.html).
# Integration von Amazon SageMaker Experiments
` durch den ARN, der zum Erstellen Ihrer Notebook-Instance verwendet wurde.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
+ Vertrauen Sie dem SageMaker AI-Serviceprinzipal, indem Sie die Schritte unter [Ändern einer Rollenvertrauensrichtlinie befolgen](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-cli.html#roles-managingrole_edit-trust-policy-cli). Fügen Sie das folgende Anweisungsfragment zur Vertrauensstellung Ihrer Rolle hinzu:
```
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
```
#### So richten Sie Ihre Umgebung ein
"
export AWS_REGION=""
```
1. Verwenden Sie den folgenden Befehl, um den OIDC-Anbieter Ihrem Cluster zuzuordnen. Weitere Informationen finden Sie unter [Aktivieren von IAM-Rollen für Service-Konten in Ihrem 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
```
Die Ausgabe sollte folgendermaßen aussehen:
```
[_] eksctl version 0.10.1
[_] using region us-east-1
[_] IAM OpenID Connect provider is associated with cluster "my-cluster" in "us-east-1"
```
Da der Cluster nun über einen OIDC-Identitätsanbieter verfügt, können Sie eine Rolle erstellen und Kubernetes ServiceAccount die Erlaubnis erteilen, die Rolle zu übernehmen.
##### Holen Sie sich die OIDC-ID
`, ``, und ``-Platzhalter durch Werte zu ersetzen, die Ihrem Cluster entsprechen.
------
#### [ 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. Führen Sie den folgenden Befehl aus, um eine Rolle mit der unter `trust.json` definierten Vertrauensstellung zu erstellen. Diese Rolle ermöglicht es dem Amazon EKS-Cluster, Anmeldeinformationen von IAM abzurufen und zu aktualisieren.
```
aws iam create-role --region ${AWS_REGION} --role-name --assume-role-policy-document file://trust.json --output=text
```
Die Ausgabe sollte folgendermaßen aussehen:
```
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/
```
Achten Sie auf `ROLE ARN`; Sie übergeben diesen Wert an Ihren Operator.
##### Hängen Sie die AmazonSageMakerFullAccess Richtlinie an die Rolle an
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
```
Die Kubernetes ServiceAccount `sagemaker-k8s-operator-default` sollten über Berechtigungen verfügen`AmazonSageMakerFullAccess`. Bestätigen Sie dies, wenn Sie den Operator installieren.
##### Bereitstellen des Operators
"
export AWS_REGION=""
```
1. Verwenden Sie den folgenden Befehl, um den OIDC-Anbieter Ihrem Cluster zuzuordnen. Weitere Informationen finden Sie unter [Aktivieren von IAM-Rollen für Service-Konten in Ihrem 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
```
Die Ausgabe sollte folgendermaßen aussehen:
```
[_] eksctl version 0.10.1
[_] using region us-east-1
[_] IAM OpenID Connect provider is associated with cluster "my-cluster" in "us-east-1"
```
Da der Cluster nun über einen OIDC-Identitätsanbieter verfügt, erstellen Sie eine Rolle und erteilen Sie Kubernetes die ServiceAccount Erlaubnis, die Rolle zu übernehmen.
##### Holen Sie sich Ihre OIDC-ID
`, ``, ``, und `` und Platzhalter durch Werte zu ersetzen, die Ihrem Cluster entsprechen. Für die Zwecke dieses Handbuchs `my-namespace` wird für den `` Wert verwendet.
------
#### [ 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. Führen Sie den folgenden Befehl aus, um eine Rolle mit der unter `trust.json` definierten Vertrauensstellung zu erstellen. Diese Rolle ermöglicht es dem Amazon EKS-Cluster, Anmeldeinformationen von IAM abzurufen und zu aktualisieren.
```
aws iam create-role --region ${AWS_REGION} --role-name --assume-role-policy-document file://trust.json --output=text
```
Die Ausgabe sollte folgendermaßen aussehen:
```
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/
```
Beachten Sie `ROLE ARN`. Sie geben diesen Wert an Ihren Operator weiter.
##### AmazonSageMakerFullAccess Ordnen Sie die Richtlinie Ihrer Rolle zu
--policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess
```
Die Kubernetes ServiceAccount `sagemaker-k8s-operator-default` sollten über Berechtigungen verfügen`AmazonSageMakerFullAccess`. Bestätigen Sie dies, wenn Sie den Operator installieren.
##### Stellen Sie den Operator in Ihrem Namespace bereit
/g' operator.yaml
```
1. Bearbeiten Sie die `operator.yaml` Datei, um Ressourcen in Ihrem `eks.amazonaws.com/role-arn` zu platzieren. Ersetzen Sie den ARN hier durch den Amazon-Ressourcennamen (ARN) für die OIDC-basierte Rolle, die Sie erstellt haben.
1. Verwenden Sie den folgenden Befehl, um den Cluster bereitzustellen:
```
kubectl apply -f operator.yaml
```
##### Stellen Sie den Operator mithilfe von Helm Charts in Ihrem Namespace bereit
helm install --n op operator_chart/
```
1. Nach einem Moment wird das Diagramm mit dem Namen `sagemaker-operator` installiert. Überprüfen Sie, ob die Installation erfolgreich war, indem Sie den folgenden Befehl ausführen:
```
helm ls
```
Die Ausgabe sollte folgendermaßen aussehen:
```
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
```
##### Überprüfen Sie die Operator-Bereitstellung in Ihrem Namespace
```
#### Löschen Sie Namespace-basierte Operatoren
```
##### Operatoren, die mit Helm Charts installiert wurden
# delete the crds
helm delete crds
# optionally delete the namespace
kubectl delete namespace
```
### Fehlerbehebung
```
+ Wenn der Job in SageMaker AI erstellt wurde, können Sie den folgenden Befehl verwenden, um das `STATUS` und das zu sehen`SageMaker Job Name`:
```
kubectl get
```
+ Sie können `smlogs` verwenden, um die Ursache des Problems mit dem folgenden Befehl zu finden:
```
kubectl smlogs
```
+ Sie können den `describe` Befehl auch verwenden, um weitere Details zum Job mithilfe des folgenden Befehls anzuzeigen. Die Ausgabe enthält ein `additional` Feld mit weiteren Informationen zum Status des Jobs.
```
kubectl describe
```
+ Wenn der Job nicht in SageMaker AI erstellt wurde, verwenden Sie die Protokolle des Pods des Operators, um die Ursache des Problems wie folgt zu ermitteln:
```
$ 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
```
#### Löschen einer Bediener-CRD
```
1. Bearbeiten Sie den Job, um den Finalizer zu löschen, indem Sie die folgenden zwei Zeilen aus der Datei entfernen. Speichern Sie die Datei und der Job wird gelöscht.
```
finalizers:
- sagemaker-operator-finalizer
```
### Bilder und SMlogs in jeder Region
`, um den `roleArn` Parameter durch Ihren und `outputPath` Ihren Amazon S3 S3-Bucket zu ersetzen, auf den die SageMaker AI-Ausführungsrolle Schreibzugriff hat. Sie `roleArn` müssen über Berechtigungen verfügen, damit SageMaker KI in Ihrem Namen auf Amazon S3 CloudWatch, Amazon und andere Dienste zugreifen kann. Weitere Informationen zur Erstellung einer SageMaker KI finden Sie ExecutionRole unter [SageMaker KI-Rollen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html#sagemaker-roles-createtrainingjob-perms). Wenden Sie die YAML-Datei mit folgendem Befehl an:
```
kubectl apply -f xgboost-mnist-trainingjob.yaml
```
### Erstellen Sie ein Diagramm TrainingJob mit Hilfe eines Helms
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:
```
### Protokolle anzeigen von TrainingJobs
```
#### Laichen 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:
```
### Logs anzeigen von 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:
```
### Protokolle anzeigen von 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:
```
Das Statusfeld enthält weitere Informationen mithilfe der folgenden Felder:
+ `Additional`: Zusätzliche Informationen über den Status des Hosting-Einsatzes. Dieses Feld ist optional und wird nur im Falle eines Fehlers ausgefüllt.
+ `Creation Time`: Als der Endpunkt in SageMaker KI erstellt wurde.
+ `Endpoint ARN`: Der SageMaker KI-Endpunkt ARN.
+ `Endpoint Config Name`: Der SageMaker AI-Name der Endpunktkonfiguration.
+ `Endpoint Name`: Der SageMaker AI-Name des Endpunkts.
+ `Endpoint Status`: Der Status des Endpunkts.
+ `Endpoint URL`: Die HTTPS-URL, die für den Zugriff auf den Endpunkt verwendet werden kann. Weitere Informationen finden Sie unter [Bereitstellen eines Modells auf SageMaker KI-Hostingdiensten](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html).
+ `FailureReason`: Wenn ein Befehl zum Erstellen, Aktualisieren oder Löschen fehlschlägt, wird die Ursache hier angezeigt.
+ `Last Check Time`: Das letzte Mal, dass der Operator den Status des Endpunkts überprüft hat.
+ `Last Modified Time`: Das letzte Mal wurde der Endpunkt geändert.
+ `Model Names`: Ein Schlüssel-Wert-Paar von HostingDeployment Modellnamen zu SageMaker KI-Modellnamen.
### Aufrufen des Endpunkts
\
--body $(seq 784 | xargs echo | sed 's/ /,/g') \
>(cat) \
--content-type text/csv > /dev/null
```
Wenn Ihre Region beispielsweise lautet `us-east-2` und Ihr Endpunkt-Konfigurationsname lautet `host-xgboost-f56b6b280d7511ea824b129926example`, würde der folgende Befehl den Endpunkt aufrufen:
```
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
```
Hier ist `4.95847082138` die Vorhersage aus dem Modell für die Scheindaten.
### Aktualisieren 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
```
Sie `sagemaker-execution-role` müssen über Berechtigungen verfügen, damit SageMaker KI in Ihrem Namen auf Ihren S3-Bucket CloudWatch, Amazon und andere Dienste zugreifen kann. Weitere Informationen zum Erstellen einer Ausführungsrolle finden Sie unter [SageMaker KI-Rollen](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html#sagemaker-roles-createtrainingjob-perms).
1. Wenden Sie die YAML-Datei mit einem der folgenden Befehle an.
Für eine Installation im Clusterbereich:
```
kubectl apply -f kmeans-mnist-processingjob.yaml
```
Für eine Installation im Namespace-Bereich:
```
kubectl apply -f kmeans-mnist-processingjob.yaml -n
```
### Liste ProcessingJobs
kmeans-mnist-processing
```
Ihre Ausgabe sollte wie folgt aussehen:
```
NAME STATUS CREATION-TIME SAGEMAKER-JOB-NAME
kmeans-mnist-processing InProgress 2020-09-22T21:13:25Z kmeans-mnist-processing-7410ed52fd1811eab19a165ae9f9e385
```
In der Ausgabe werden alle Aufträge unabhängig von ihrem Status aufgeführt. Informationen zum Entfernen eines Auftrags aus der Liste finden Sie unter [Löschen eines Verarbeitungsauftrags](https://docs.aws.amazon.com/sagemaker/latest/dg/kubernetes-processing-job-operator.html#kubernetes-processing-job-delete).
**ProcessingJob Status**
+ `SynchronizingK8sJobWithSageMaker`– Der Auftrag wird zuerst an den Cluster übermittelt. Der Operator hat die Anforderung erhalten und bereitet die Erstellung des Verarbeitungsauftrags vor.
+ `Reconciling`– Der Operator initialisiert oder behebt vorübergehende Fehler und andere Fehler. Bleibt der Verarbeitungsauftrag in diesem Status, verwenden Sie den `kubectl` `describe` Befehl, um den Grund im Feld `Additional` zu ermitteln.
+ `InProgress | Completed | Failed | Stopping | Stopped`— Status des SageMaker Verarbeitungsauftrags. Weitere Informationen finden Sie unter [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html#sagemaker-DescribeProcessingJob-response-ProcessingJobStatus).
+ `Error`– Der Operator kann die Wiederherstellung nicht durch einen Abgleich durchführen.
Für Aufträge, die abgeschlossen, gestoppt oder fehlgeschlagen sind, fallen keine weiteren Gebühren für SageMaker KI-Ressourcen an.
### Beschreiben Sie ein ProcessingJob
```
Die Ausgabe Ihres Verarbeitungsauftrags sollte in etwa so aussehen wie die folgende.
```
$ 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:
```
### Lösche ein ProcessingJob
```
Die Ausgabe Ihres Verarbeitungsauftrags sollte in etwa so aussehen wie die folgende.
```
processingjob.sagemaker.aws.amazon.com "kmeans-mnist-processing" deleted
```
**Anmerkung**
SageMaker AI löscht den Verarbeitungsjob nicht. Gestoppte Jobs werden weiterhin in der SageMaker AI-Konsole angezeigt. Der `delete` Befehl benötigt einige Minuten, um die Ressourcen aus der SageMaker KI zu bereinigen.
## HostingAutoscalingPolicy (HAP) Betreiber
```
#### Beispiel 2: Wenden Sie eine benutzerdefinierte Metrik auf eine einzelne Endpunktvariante an
```
#### Beispiel 3: Wenden Sie eine Skalierungsrichtlinie auf mehrere Endpunkte und Varianten an
```
#### Überlegungen HostingAutoscalingPolicies für mehrere Endpunkte und Varianten
```
Ihre Ausgabe sollte wie folgt aussehen:
```
NAME STATUS CREATION-TIME
hap-predefined Created 2021-07-13T21:32:21Z
```
Verwenden Sie den folgenden Befehl, um den Status Ihres HostingAutoscalingPolicy (HAP) zu überprüfen.
```
kubectl get hap
```
Es wird einer der folgenden Werte zurückgegeben:
+ `Reconciling` – Bei bestimmten Fehlertypen wird der Status als `Reconciling` statt als `Error` angezeigt. Einige Beispiele sind serverseitige Fehler und Endpunkte im Status `Creating` oder `Updating`. Prüfen Sie das Feld `Additional` in den Status- oder Bedienerprotokollen für weitere Einzelheiten.
+ `Created`
+ `Error`
**Um den Autoscaling-Endpunkt anzuzeigen, auf den Sie die Richtlinie angewendet haben**
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Erweitern Sie im linken Seitenbereich die Option **Inferenz**.
1. Wählen Sie **Endpunkte** aus.
1. Wählen Sie den Namen des interessierenden Endpunkts aus.
1. Blättern Sie zum Abschnitt **Endpunkt-Laufzeiteinstellungen**.
### Beschreiben Sie ein HostingAutoscalingPolicy
```
### Aktualisieren Sie ein HostingAutoscalingPolicy
```
Dieser Befehl löscht die Skalierungsrichtlinie und hebt die Registrierung des Skalierungsziels bei Kubernetes auf. Dieser Befehl liefert die folgende Ausgabe:
```
hostingautoscalingpolicies.sagemaker.aws.amazon.com "hap-predefined" deleted
```
### Aktualisieren oder löschen Sie einen Endpunkt mit einem HostingAutoscalingPolicy
` durch einen beliebigen Namen für Ihren Cluster.
```
eksctl create cluster --name --region us-east-1 --auto-kubeconfig --timeout=50m --managed --nodes=1
```
1. Wenn die Cluster-Erstellung abgeschlossen ist, stellen Sie sicher, dass Sie Zugriff auf Ihren Cluster haben, indem Sie die Knoten des Clusters auflisten.
```
kubectl get nodes
```
1. Stellen Sie mit dem folgenden Befehl sicher, dass der aktuelle `kubectl` Kontext auf Ihren Cluster verweist. Der aktuelle Kontext ist in der Ausgabe mit einem Sternchen (\$1) gekennzeichnet.
```
kubectl config get-contexts
CURRENT NAME CLUSTER
* @.us-east-1.eksctl.io .us-east-1.eksctl.io
```
1. Wenn der gewünschte Cluster nicht als Ihr aktueller Standard konfiguriert ist, aktualisieren Sie den Standard mit dem folgenden Befehl.
```
aws eks update-kubeconfig --name --region us-east-1
```
#### Installieren von 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
```
## Konfigurieren Sie Ihre Pipeline-Berechtigungen für den Zugriff auf KI SageMaker
Um SageMaker AI Components Version 1 für Kubeflow Pipelines ausführen zu können, benötigen die Kubeflow Pipeline-Pods Zugriff auf KI. SageMaker
**Wichtig**
Folgen Sie diesem Abschnitt, unabhängig davon, ob Sie die vollständige Version von Kubeflow bei der Bereitstellung oder die eigenständige Version von Kubeflow Pilepines verwenden. AWS
Gehen Sie wie folgt vor, um eine IAM-Ausführungsrolle zu erstellen, die den Kubeflow-Pipeline-Pods Zugriff auf KI gewährt: SageMaker
1. Exportieren Sie Ihren Clusternamen (z. B. *my-cluster-name*) und Ihre Cluster-Region (z. B. *us-east-1*).
```
export CLUSTER_NAME=my-cluster-name
export CLUSTER_REGION=us-east-1
```
1. Exportieren Sie den Namespace und den Namen des Service-Kontos entsprechend Ihrer Installation.
+ Für den vollständigen Kubeflow bei der AWS Installation exportieren Sie Ihr Profil `namespace` (z. B. *kubeflow-user-example-com*) und den *Standardeditor* als Dienstkonto.
```
export NAMESPACE=kubeflow-user-example-com
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=default-editor
```
+ Exportieren Sie für die eigenständige Pipelines-Bereitstellung *Kubeflow* als `namespace` und *Pipeline-Runner* als Service-Konto.
```
export NAMESPACE=kubeflow
export KUBEFLOW_PIPELINE_POD_SERVICE_ACCOUNT=pipeline-runner
```
1. Erstellen Sie einen [ IAM OIDC-Anbieter für den Amazon EKS-Cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) mit dem folgenden Befehl.
```
eksctl utils associate-iam-oidc-provider --cluster ${CLUSTER_NAME} \
--region ${CLUSTER_REGION} --approve
```
1. Erstellen Sie eine IAM-Ausführungsrolle für die KFP-Pods, um auf Dienste (AI,) zuzugreifen. 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
```
[Sobald Ihre Pipeline-Berechtigungen für den Zugriff auf SageMaker AI Components Version 1 konfiguriert sind, folgen Sie dem Leitfaden SageMaker KI-Komponenten für Kubeflow-Pipelines in der Kubeflow-Dokumentation. AWS](https://awslabs.github.io/kubeflow-manifests/docs/amazon-sagemaker-integration/sagemaker-components-for-kubeflow-pipelines/)
## Greifen Sie auf die KFP-Benutzeroberfläche zu (Kubeflow Dashboard)
80/TCP 2d22h
```
1. Führen Sie den folgenden Befehl aus, um die Portweiterleitung zum KFP UI Service einzurichten. Dadurch wird die KFP-Benutzeroberfläche an Port 8080 auf Ihrem Gateway-Knoten weitergeleitet und Sie können von Ihrem Browser aus auf die KFP-Benutzeroberfläche zugreifen.
```
kubectl port-forward -n kubeflow service/ml-pipeline-ui 8080:80
```
Die Portweiterleitung von Ihrem Remote-Computer wird unterbrochen, wenn keine Aktivität stattfindet. Führen Sie diesen Befehl erneut aus, wenn Ihr Dashboard keine Protokolle oder Updates abrufen kann. Wenn die Befehle einen Fehler zurückgeben, stellen Sie sicher, dass auf dem Port, den Sie verwenden möchten, bereits kein Prozess läuft.
#### Greifen Sie auf den KFP-UI-Service zu
` durch die IP-Adresse Ihrer Instance auf der Amazon-EC2-Konsole. Sie können auch das öffentliche DNS verwenden. Ersetzen Sie `` durch den Pfad zu dem PEM-Schlüssel, der für den Zugriff auf den Gateway-Knoten verwendet wird.
```
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. Greifen Sie in Ihrem Browser auf das Dashboard zu.
```
http://localhost:9000
```
1. Wählen Sie **Pipelines**, um auf die KFP-Benutzeroberfläche zuzugreifen.
#### (Optional) Gewähren Sie SageMaker KI-Notebook-Instances Zugriff auf Amazon EKS und führen Sie KFP-Pipelines von Ihrem Notebook aus aus aus.
` durch den Namen Ihrer Instance.
```
aws sagemaker describe-notebook-instance --notebook-instance-name --region --output text --query 'RoleArn'
```
Dieser Befehl gibt die IAM-Rolle ARN im folgenden `arn:aws:iam:::role/` Format aus. Notieren Sie sich diesen ARN.
1. Führen Sie diesen Befehl aus, um die folgenden Richtlinien (Amazon AmazonSageMakerFullAccess EKSWorkerNodePolicy, AmazonS3FullAccess) an diese IAM-Rolle anzuhängen. Ersetzen Sie `` durch `` in Ihrem ARN.
```
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. Amazon EKS-Cluster verwenden IAM-Rollen, um den Zugriff auf den Cluster zu steuern. Die Regeln sind in einer Konfigurationsübersicht mit dem Namen `aws-auth` implementiert. `eksctl` stellt Befehle zum Lesen und Bearbeiten der `aws-auth` Config-Map bereit. Nur Benutzer, die Zugriff auf den Cluster haben, können diese Konfigurationsübersicht bearbeiten.
`system:masters` ist eine der Standardbenutzergruppen mit Superuser-Rechten für den Cluster. Fügen Sie Ihren Benutzer zu dieser Gruppe hinzu oder erstellen Sie eine Gruppe mit restriktiveren Berechtigungen.
1. Binden Sie die Rolle an Ihren Cluster, indem Sie den folgenden Befehl ausführen. Ersetzen Sie `` durch den ARN der IAM-Rolle. `` kann ein beliebiger eindeutiger Benutzername sein.
```
eksctl create iamidentitymapping \
--cluster \
--arn \
--group system:masters \
--username \
--region
```
1. Öffnen Sie ein Jupyter-Notebook auf Ihrer SageMaker AI-Instance und führen Sie den folgenden Befehl aus, um sicherzustellen, dass es Zugriff auf den Cluster hat.
```
aws eks --region update-kubeconfig --name
kubectl -n kubeflow get all | grep pipeline
```
# Verwenden Sie KI-Komponenten SageMaker
` in den Namen Ihres Amazon-S3-Buckets.
```
aws s3 cp mnist-kmeans-sagemaker/kmeans_preprocessing.py s3:///mnist_kmeans_example/processing_code/kmeans_preprocessing.py
```
### Kompilieren und implementieren Sie Ihre Pipeline
` durch den Pfad zu Ihrer Pipeline und `` durch den Speicherort, an dem sich Ihre Datei tar.gz befinden soll.
```
dsl-compile --py --output
```
#### Laden Sie die Pipeline mit der KFP-CLI hoch und führen Sie sie aus
```
Die Ausgabe sollte wie folgt aussehen. Beachten Sie die 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. Erstellen Sie einen Lauf mit dem folgenden Befehl. Der KFP-CLI-Run-Befehl unterstützt derzeit nicht die Angabe von Eingabeparametern bei der Erstellung des Laufs. Sie müssen Ihre Parameter in der AWS SDK für Python (Boto3) Pipeline-Datei vor dem Kompilieren aktualisieren. Ersetzen Sie `` und `` durch beliebige Namen. Ersetzen Sie `` durch die ID Ihrer eingereichten Pipeline. Ersetzen Sie `` durch den ARN von `kfp-example-pod-role`. Ersetzen Sie `` durch den Namen des von Ihnen erstellten Amazon-S3-Buckets.
```
kfp run submit --experiment-name --run-name --pipeline-id role_arn="" bucket_name=""
```
Sie können einen Lauf auch direkt einreichen, indem Sie das kompilierte Pipeline-Paket verwenden, das als Ausgabe des `dsl-compile` Befehls erstellt wurde.
```
kfp run submit --experiment-name --run-name --package-file role_arn="" bucket_name=""
```
Die Ausgabe sollte folgendermaßen aussehen:
```
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. Navigieren Sie zur Benutzeroberfläche, um den Fortschritt des Auftrags zu überprüfen.
#### Laden Sie die Pipeline mit der KFP-Benutzeroberfläche hoch und führen Sie sie aus
./sagemaker-invoke.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint"
],
"Resource": "*"
}
]
}
EoF
```
1. Fügen Sie die Richtlinie der IAM-Rolle des Client-Knotens an.
Führen Sie den folgenden Befehl aus. Ersetzen Sie `` durch den Namen der IAM-Rolle. Ersetzen Sie `` durch den Pfad zu der von Ihnen erstellten Richtliniendatei.
```
aws iam put-role-policy --role-name --policy-name sagemaker-invoke-for-worker --policy-document file://
```
#### Vorhersagen ausführen
'
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. Führen Sie die AWS SDK für Python (Boto3) Datei wie folgt aus:
```
python mnist-predictions.py
```
### Ergebnisse und Protokolle anzeigen
```
### Bereinigen
```
1. Melden Sie sich mit Ihrem AWS Konto beim SageMaker AI-Service an. Beenden Sie manuell alle Trainings-, Batch-Transform- und HPO-Aufträge. Löschen Sie Modelle, Daten-Buckets und Endpunkte, um zusätzliche Kosten zu vermeiden. Durch das Beenden der Pipeline-Läufe werden die Jobs in SageMaker AI nicht gestoppt.
# SageMaker Notizbuch-Jobs
.
1. Wählen Sie **Fertig** aus.
# Details zum Trainingsjob aktualisieren (Studio)
.
1. Wählen Sie **Fertig** aus.
# Aktualisieren Sie einen Evaluierungsjob (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/
/*\"]}]}"
```
**Anmerkung**
Verschiedene Kombinationen von Aktionen können an die Ressourcenrichtlinie angehängt werden. Bei benutzerdefinierten Richtlinien sollte die erstellte Berechtigung vom Eigentümer der Modellpaketgruppe heraufgestuft werden, sodass nur Entitäten mit angehängten hochgestuften Berechtigungen auffindbar sind. Ressourcenfreigaben, die nicht heraufgestuft werden können, können nicht auffindbar gemacht oder verwaltet werden. AWS RAM
1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob der Resource Share ARN AWS RAM erstellt wurde:
```
aws ram get-resource-share-associations --association-type resource --resource-arn
```
Die Antwort enthält die *resource-share-arn* für die Entität.
1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob es sich bei der angehängten Richtlinienberechtigung um eine verwaltete oder benutzerdefinierte Richtlinie handelt:
```
aws ram list-resource-share-permissions --resource-share-arn
```
Das `featureSet` Feld kann Werte `CREATED_FROM_POLICY` oder annehmen`STANDARD`, die wie folgt definiert sind:
+ `STANDARD`: Die Erlaubnis ist bereits vorhanden.
+ `CREATED_FROM_POLICY`: Die Berechtigung muss erhöht werden, damit die Entität auffindbar ist. Weitere Informationen finden Sie unter [Werben Sie für die Berechtigung und die gemeinsame Nutzung der Ressource](model-registry-ram-promote.md).
1. Nehmen Sie die Einladung zur gemeinsamen Nutzung von Ressourcen im Modell-Kundenkonto an.
1. Der Nutzer der Modellpaketgruppe akzeptiert die Einladung zur gemeinsamen Nutzung von Ressourcen. Führen Sie den folgenden Befehl aus, um alle Ressourceneinladungen anzuzeigen:
```
aws ram get-resource-share-invitations
```
Identifizieren Sie die Anfragen, die Status haben `PENDING` und die Konto-ID des Eigentümerkontos enthalten.
1. Nehmen Sie die Einladung zur gemeinsamen Nutzung von Ressourcen durch den Modellbesitzer an, indem Sie den folgenden Befehl verwenden:
```
aws ram accept-resource-share-invitation --resource-share-invitation-arn
```
------
#### [ AWS RAM console ]
1. Melden Sie sich an der [AWS RAM -Konsole](https://console.aws.amazon.com/ram/home) an.
1. Gehen Sie folgendermaßen vor, um eine Ressourcenfreigabe über das Konto des Modellpaketgruppen-Eigentümers zu erstellen.
1. Führen Sie die folgenden Schritte aus, um Details zur Ressourcenfreigabe anzugeben.
1. Fügen Sie im Feld **Name** einen eindeutigen Namen für Ihre Ressource hinzu.
1. Wählen Sie auf der Karte **Ressourcen** das Dropdownmenü aus und wählen Sie **SageMaker AI Model Package Groups** aus.
1. Aktivieren Sie das Kontrollkästchen neben der ARN der Ressourcenfreigabe für Modellpaketgruppen.
1. Aktivieren Sie auf der Karte **„Ressourcen** auswählen“ das Kontrollkästchen für die Ressourcenfreigabe Ihrer Modellpaketgruppe.
1. Fügen Sie auf der Karte „**Tags**“ Schlüssel-Wert-Paare für Tags hinzu, die Sie Ihrer Ressourcenfreigabe hinzufügen möchten.
1. Wählen Sie **Weiter** aus.
1. Führen Sie die folgenden Schritte aus, um der Ressourcenfreigabe verwaltete Berechtigungen zuzuweisen.
1. Wenn Sie eine verwaltete Berechtigung verwenden, wählen Sie im Dropdownmenü **Verwaltete Berechtigungen eine verwaltete** Berechtigung aus.
1. Wenn Sie eine benutzerdefinierte Berechtigung verwenden, wählen Sie vom **Kunden verwaltete Berechtigung** aus. In diesem Fall ist die Modellpaketgruppe nicht sofort auffindbar. Nachdem Sie die Ressourcenfreigabe erstellt haben, müssen Sie die Berechtigung und die Ressourcenrichtlinie heraufstufen. Weitere Informationen zum Heraufstufen von Berechtigungen und zur gemeinsamen Nutzung von Ressourcen finden Sie unter[Werben Sie für die Berechtigung und die gemeinsame Nutzung der Ressource](model-registry-ram-promote.md). Weitere Informationen zum anfügen benutzerdefinierter Berechtigungen finden Sie unter Vom [Kunden verwaltete Berechtigungen erstellen und verwenden in AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/create-customer-managed-permissions.html).
1. Wählen Sie **Weiter** aus.
1. Führen Sie die folgenden Schritte aus, um den Hauptbenutzern Zugriff zu gewähren.
1. Wählen Sie **Teilen mit anderen** zulassen, um das Teilen mit Konten außerhalb Ihrer Organisation zuzulassen, oder wählen Sie **Teilen nur innerhalb Ihrer Organisation zulassen** aus.
1. Fügen **Sie im Dropdownmenü Prinzipaltyp auswählen** die Prinzipaltypen und die ID für die Principals hinzu, die Sie hinzufügen möchten.
1. Fügen Sie die ausgewählten Principals für die Aktie hinzu und wählen Sie sie aus.
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie die angezeigte Freigabekonfiguration und wählen Sie dann **Create resource share** aus.
1. Nehmen Sie die Einladung zur gemeinsamen Nutzung von Ressourcen vom Kundenkonto an. Sobald der Modellbesitzer die Ressourceneinheit und die Prinzipalzuordnungen erstellt hat, erhalten die angegebenen Ressourcennutzerkonten eine Einladung, der Ressourceneinheit beizutreten. Die Ressourcennutzerkonten können die Einladungen in der AWS RAM -Konsole auf der Seite [Für mich freigegeben: Ressourcenfreigaben](https://console.aws.amazon.com/ram/home#SharedResourceShares:) anzeigen und annehmen. Weitere Informationen zum Akzeptieren und Anzeigen von Ressourcen finden Sie unter [Zugreifen auf mit Ihnen geteilte AWS Ressourcen](https://docs.aws.amazon.com//ram/latest/userguide/working-with-shared.html). AWS RAM
------
# Gemeinsam genutzte Modellpaketgruppen anzeigen
--principals
```
Verwenden Sie den Befehl [delete-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/delete-resource-share.html)wie folgt, um eine Ressourcenfreigabe zu löschen:
```
aws ram delete-resource-share --resource-share-arn
```
## AWS RAM Konsole
```
1. Bewerben Sie die Ressourcenfreigabe mit dem folgenden Befehl:
```
aws ram promote-resource-share-created-from-policy --resource-share-arn
```
Wenn der `OperationNotPermittedException` Fehler bei der Ausführung der vorherigen Schritte auftritt, ist die Entität nicht auffindbar, aber sie ist zugänglich. Wenn der Besitzer der Ressource beispielsweise eine Ressourcenrichtlinie mit einer übernommenen Rolle als Principal anhängt`“Principal”: {“AWS”: “arn:aws:iam::3333333333:role/Role-1”}`, oder wenn die Ressourcenrichtlinie dies zulässt`“Action”: “*”`, ist die zugehörige Modellpaketgruppe weder heraufstufbar noch auffindbar.
# Den Bereitstellungsverlauf eines Modells anzeigen
```
Verwenden Sie dann die AWS Konsolen-, Python- oder [UpdateProject](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateProject.html)API-Operationen, um ein SageMaker Projekt anhand von Vorlagen im S3-Bucket zu erstellen oder zu aktualisieren. [CreateProject](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProject.html)
------
#### [ Studio ]
**Erstellen eines Projekts**
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Öffnen Sie die SageMaker Studio-Konsole, indem Sie den Anweisungen unter [Amazon SageMaker Studio starten](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) folgen.
1. Wählen Sie im linken Navigationsbereich **Bereitstellungen**, **Projekte**, **Projekt erstellen** aus.
1. Wählen Sie **Organisationsvorlagen** und dann **S3-Vorlagen** aus, um die Vorlagen zu sehen, die Ihnen zur Verfügung stehen. Wenn Sie keine Vorlage sehen, die Sie erwarten, benachrichtigen Sie Ihren Administrator.
1. Wählen Sie die Vorlage aus, die Sie verwenden möchten, und klicken Sie dann auf **Weiter**.
1. Geben Sie einen Namen für Ihr Projekt, eine optionale Beschreibung und die anderen erforderlichen Felder ein. Wählen Sie anschließend **Erstellen** aus.
**Aktualisieren Sie ein Projekt**
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Öffnen Sie die SageMaker Studio-Konsole, indem Sie den Anweisungen unter [Amazon SageMaker Studio starten](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html) folgen.
1. Wählen Sie das Projekt aus, das Sie aktualisieren möchten. Wählen Sie „**Aktionen**“ und anschließend „**Projekt aktualisieren“**.
1. Wenn Sie ein Projekt aktualisieren, können Sie die Vorlagenparameter oder die Vorlagen-URL aktualisieren. Wählen Sie abschließend **Weiter**.
1. **Sehen Sie sich die Projektaktualisierungen in der Übersichtstabelle an und wählen Sie Aktualisieren aus.**
------
#### [ Python Boto3 ]
Nachdem Sie den S3-Bucket erstellt und Ihre Vorlagen hochgeladen haben, können Sie das folgende Beispiel verwenden, um ein SageMaker Projekt zu erstellen.
```
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']}")
```
Informationen zum Aktualisieren eines SageMaker Projekts finden Sie im folgenden Beispiel.
```
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']}")
```
------
# Projektressourcen anzeigen