D'autres exemples de AWS SDK sont disponibles dans le référentiel [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation `CreateAssetModel` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `CreateAssetModel`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](iotsitewise_example_iotsitewise_Scenario_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour créer un modèle de ressource**
L’exemple `create-asset-model` suivant crée un modèle de ressource qui définit une éolienne avec les propriétés suivantes :
Numéro de série - Le numéro de série d'une éolienne L'énergie produite par une éolienne - Le flux de données de puissance généré par une éolienne Température C - Le flux de données de température d'une éolienne en CelsiusTemperature F - Les points de données de température cartographiés de Celsius à Fahrenheit
```
aws iotsitewise create-asset-model \
--cli-input-json file://create-wind-turbine-model.json
```
Contenu de `create-wind-turbine-model.json` :
```
{
"assetModelName": "Wind Turbine Model",
"assetModelDescription": "Represents a wind turbine",
"assetModelProperties": [
{
"name": "Serial Number",
"dataType": "STRING",
"type": {
"attribute": {}
}
},
{
"name": "Generated Power",
"dataType": "DOUBLE",
"unit": "kW",
"type": {
"measurement": {}
}
},
{
"name": "Temperature C",
"dataType": "DOUBLE",
"unit": "Celsius",
"type": {
"measurement": {}
}
},
{
"name": "Temperature F",
"dataType": "DOUBLE",
"unit": "Fahrenheit",
"type": {
"transform": {
"expression": "temp_c * 9 / 5 + 32",
"variables": [
{
"name": "temp_c",
"value": {
"propertyId": "Temperature C"
}
}
]
}
}
},
{
"name": "Total Generated Power",
"dataType": "DOUBLE",
"unit": "kW",
"type": {
"metric": {
"expression": "sum(power)",
"variables": [
{
"name": "power",
"value": {
"propertyId": "Generated Power"
}
}
],
"window": {
"tumbling": {
"interval": "1h"
}
}
}
}
}
]
}
```
Sortie :
```
{
"assetModelId": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"assetModelArn": "arn:aws:iotsitewise:us-west-2:123456789012:asset-model/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"assetModelStatus": {
"state": "CREATING"
}
}
```
Pour plus d'informations, consultez la section [Définition des modèles d'actifs](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/define-models.html) dans le *Guide de l' SiteWise utilisateur de l'AWS IoT*.
+ Pour plus de détails sur l'API, reportez-vous [CreateAssetModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotsitewise/create-asset-model.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/iotsitewise#code-examples).
```
/**
* Creates an asset model.
*
* @param name the name of the asset model to create.
* @return a {@link CompletableFuture} that represents a {@link CreateAssetModelResponse} result. The calling code
* can attach callbacks, then handle the result or exception by calling {@link CompletableFuture#join()} or
* {@link CompletableFuture#get()}.
*
* If any completion stage in this method throws an exception, the method logs the exception cause and keeps it
* available to the calling code as a {@link CompletionException}. By calling
* {@link CompletionException#getCause()}, the calling code can access the original exception.
*/
public CompletableFuture createAssetModelAsync(String name) {
PropertyType humidity = PropertyType.builder()
.measurement(Measurement.builder().build())
.build();
PropertyType temperaturePropertyType = PropertyType.builder()
.measurement(Measurement.builder().build())
.build();
AssetModelPropertyDefinition temperatureProperty = AssetModelPropertyDefinition.builder()
.name("Temperature")
.dataType(PropertyDataType.DOUBLE)
.type(temperaturePropertyType)
.build();
AssetModelPropertyDefinition humidityProperty = AssetModelPropertyDefinition.builder()
.name("Humidity")
.dataType(PropertyDataType.DOUBLE)
.type(humidity)
.build();
CreateAssetModelRequest createAssetModelRequest = CreateAssetModelRequest.builder()
.assetModelName(name)
.assetModelDescription("This is my asset model")
.assetModelProperties(temperatureProperty, humidityProperty)
.build();
return getAsyncClient().createAssetModel(createAssetModelRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
logger.error("Failed to create asset model: {} ", exception.getCause().getMessage());
}
});
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateAssetModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/iotsitewise-2019-12-02/CreateAssetModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/iotsitewise#code-examples).
```
import {
CreateAssetModelCommand,
IoTSiteWiseClient,
} from "@aws-sdk/client-iotsitewise";
import { parseArgs } from "node:util";
/**
* Create an Asset Model.
* @param {{ assetName : string, assetModelId: string }}
*/
export const main = async ({ assetModelName, assetModelId }) => {
const client = new IoTSiteWiseClient({});
try {
const result = await client.send(
new CreateAssetModelCommand({
assetModelName: assetModelName, // The name to give the Asset Model.
}),
);
console.log("Asset model created successfully.");
return result;
} catch (caught) {
if (caught instanceof Error && caught.name === "IoTSiteWiseError") {
console.warn(
`${caught.message}. There was a problem creating the asset model.`,
);
} else {
throw caught;
}
}
};
```
+ Pour plus de détails sur l'API, reportez-vous [CreateAssetModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/iotsitewise/command/CreateAssetModelCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/iotsitewise#code-examples).
```
class IoTSitewiseWrapper:
"""Encapsulates AWS IoT SiteWise actions using the client interface."""
def __init__(self, iotsitewise_client: client) -> None:
"""
Initializes the IoTSitewiseWrapper with an AWS IoT SiteWise client.
:param iotsitewise_client: A Boto3 AWS IoT SiteWise client. This client provides low-level
access to AWS IoT SiteWise services.
"""
self.iotsitewise_client = iotsitewise_client
self.entry_id = 0 # Incremented to generate unique entry IDs for batch_put_asset_property_value.
@classmethod
def from_client(cls) -> "IoTSitewiseWrapper":
"""
Creates an IoTSitewiseWrapper instance with a default AWS IoT SiteWise client.
:return: An instance of IoTSitewiseWrapper initialized with the default AWS IoT SiteWise client.
"""
iotsitewise_client = boto3.client("iotsitewise")
return cls(iotsitewise_client)
def create_asset_model(
self, asset_model_name: str, properties: List[Dict[str, Any]]
) -> str:
"""
Creates an AWS IoT SiteWise Asset Model.
:param asset_model_name: The name of the asset model to create.
:param properties: The property definitions of the asset model.
:return: The ID of the created asset model.
"""
try:
response = self.iotsitewise_client.create_asset_model(
assetModelName=asset_model_name,
assetModelDescription="This is a sample asset model description.",
assetModelProperties=properties,
)
asset_model_id = response["assetModelId"]
waiter = self.iotsitewise_client.get_waiter("asset_model_active")
waiter.wait(assetModelId=asset_model_id)
return asset_model_id
except ClientError as err:
if err.response["Error"]["Code"] == "ResourceAlreadyExistsException":
logger.error("Asset model %s already exists.", asset_model_name)
else:
logger.error(
"Error creating asset model %s. Here's why %s",
asset_model_name,
err.response["Error"]["Message"],
)
raise
```
Voici un exemple de liste de propriétés à transmettre à la fonction.
```
properties = [
{
"name": temperature_property_name,
"dataType": "DOUBLE",
"type": {
"measurement": {},
},
},
{
"name": humidity_property_name,
"dataType": "DOUBLE",
"type": {
"measurement": {},
},
},
]
```
+ Pour plus de détails sur l'API, consultez [CreateAssetModel](https://docs.aws.amazon.com/goto/boto3/iotsitewise-2019-12-02/CreateAssetModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/ios#code-examples).
```
TRY.
oo_result = lo_ios->createassetmodel(
iv_assetmodelname = iv_asset_model_name
iv_assetmodeldescription = 'This is a sample asset model description.'
it_assetmodelproperties = it_properties
). " oo_result is returned for testing purposes. "
MESSAGE 'IoT SiteWise asset model created' TYPE 'I'.
CATCH /aws1/cx_iosresrcalrdyexistsex.
MESSAGE 'Asset model already exists.' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez [CreateAssetModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------