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.

# Démarrage d'une tâche d'importation
<a name="start-dicom-import-job"></a>

Utilisez cette `StartDICOMImportJob` action pour démarrer un contrôle de [vérification des données de pixels](pixel-data-verification.md) et une importation de données en masse dans un [magasin de HealthImaging données](getting-started-concepts.md#concept-data-store) AWS. La tâche d'importation importe des fichiers DICOM P10 ou améliore les fichiers DICOM existants avec des métadonnées JSON. Le `inputS3Uri` paramètre spécifie le compartiment d'entrée Amazon S3 contenant les fichiers source. Les résultats du traitement des tâches d'importation sont stockés dans le compartiment de sortie Amazon S3 spécifié par le `outputS3Uri` paramètre.

**Note**  
Tenez compte des points suivants avant de commencer une tâche d'importation :  
HealthImaging prend en charge l'importation de fichiers DICOM P10 avec différentes syntaxes de transfert. Certains fichiers conservent leur syntaxe de transfert d'origine lors de l'importation, tandis que d'autres sont transcodés au format HTJ2K sans perte par défaut ou au format JPEG 2000 sans perte selon la configuration de votre banque de données. Pour de plus amples informations, veuillez consulter [Syntaxes de transfert prises en charge](supported-transfer-syntaxes.md).
HealthImaging prend en charge les importations de données à partir de compartiments Amazon S3 situés dans d'autres [régions prises en charge](endpoints-quotas.md#endpoints). Pour obtenir cette fonctionnalité, fournissez le `inputOwnerAccountId` paramètre lors du démarrage d'une tâche d'importation. Pour de plus amples informations, veuillez consulter [Importation entre comptes pour AWS HealthImaging](cross-account-imports.md).
HealthImaging applique des contraintes de longueur à des éléments DICOM spécifiques lors de l'importation. Pour de plus amples informations, veuillez consulter [Contraintes relatives aux éléments DICOM](dicom-element-constraints.md).
Pour importer des fichiers DICOM avec des remplacements de métadonnées JSON, fournissez au `importConfiguration` paramètre un `DicomMetadataMapping` qui fait correspondre les fichiers DICOM aux fichiers de métadonnées JSON correspondants. Pour plus d'informations, consultez [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_StartDICOMImportJob.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_StartDICOMImportJob.html)le manuel de *référence des HealthImaging API AWS*.

Les menus suivants fournissent une procédure AWS Management Console et des exemples de code pour AWS CLI les AWS SDK. Pour plus d'informations, consultez [https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_StartDICOMImportJob.html](https://docs.aws.amazon.com/healthimaging/latest/APIReference/API_StartDICOMImportJob.html)le manuel de *référence des HealthImaging API AWS*.

**Pour démarrer une tâche d’importation**  
Choisissez un menu en fonction de vos préférences d'accès à AWS HealthImaging.

## AWS Console
<a name="code-example-console-import-job-start"></a>

1. Ouvrez la [page HealthImaging Stockages de données de la](https://console.aws.amazon.com/medical-imaging/home#/dataStores) console.

1. Choisissez un magasin de données.

1. Choisissez **Importer des données DICOM**.

   La page **Importer des données DICOM** s'ouvre.

1. Dans la section **Détails**, entrez les informations suivantes :
   + **Nom** (facultatif)
   + **Importer l'emplacement de la source dans S3**
   + **ID de compte du propriétaire du compartiment source** (facultatif)
   + **Clé de chiffrement** (facultatif)
   + **Destination de sortie dans S3**

1. Dans la section **Accès au service**, choisissez **Utiliser un rôle de service existant** et sélectionnez le rôle dans le menu **Nom du rôle de service** ou choisissez **Créer et utiliser un nouveau rôle de service**.

1. Choisissez **Importer**.

## AWS CLI et SDK
<a name="code-example-cli-sdk-import-job-start"></a>

------
#### [ C\+\+ ]

**SDK pour C\+\+**  

```
//! Routine which starts a HealthImaging import job.
/*!
  \param dataStoreID: The HealthImaging data store ID.
  \param inputBucketName: The name of the Amazon S3 bucket containing the DICOM files.
  \param inputDirectory: The directory in the S3 bucket containing the DICOM files.
  \param outputBucketName: The name of the S3 bucket for the output.
  \param outputDirectory: The directory in the S3 bucket to store the output.
  \param roleArn: The ARN of the IAM role with permissions for the import.
  \param importJobId: A string to receive the import job ID.
  \param clientConfig: Aws client configuration.
  \return bool: Function succeeded.
  */
bool AwsDoc::Medical_Imaging::startDICOMImportJob(
        const Aws::String &dataStoreID, const Aws::String &inputBucketName,
        const Aws::String &inputDirectory, const Aws::String &outputBucketName,
        const Aws::String &outputDirectory, const Aws::String &roleArn,
        Aws::String &importJobId,
        const Aws::Client::ClientConfiguration &clientConfig) {
    Aws::MedicalImaging::MedicalImagingClient medicalImagingClient(clientConfig);
    Aws::String inputURI = "s3://" + inputBucketName + "/" + inputDirectory + "/";
    Aws::String outputURI = "s3://" + outputBucketName + "/" + outputDirectory + "/";
    Aws::MedicalImaging::Model::StartDICOMImportJobRequest startDICOMImportJobRequest;
    startDICOMImportJobRequest.SetDatastoreId(dataStoreID);
    startDICOMImportJobRequest.SetDataAccessRoleArn(roleArn);
    startDICOMImportJobRequest.SetInputS3Uri(inputURI);
    startDICOMImportJobRequest.SetOutputS3Uri(outputURI);

    Aws::MedicalImaging::Model::StartDICOMImportJobOutcome startDICOMImportJobOutcome = medicalImagingClient.StartDICOMImportJob(
            startDICOMImportJobRequest);

    if (startDICOMImportJobOutcome.IsSuccess()) {
        importJobId = startDICOMImportJobOutcome.GetResult().GetJobId();
    }
    else {
        std::cerr << "Failed to start DICOM import job because "
                  << startDICOMImportJobOutcome.GetError().GetMessage() << std::endl;
    }

    return startDICOMImportJobOutcome.IsSuccess();
}
```
+  Pour plus de détails sur l'API, reportez-vous [StartDICOMImportJob](https://docs.aws.amazon.com/goto/SdkForCpp/medical-imaging-2023-07-19/StartDICOMImportJob)à la section *Référence des AWS SDK pour C\+\+ API*. 
 Il y en a plus sur 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/cpp/example_code/medical-imaging/#code-examples). 

------
#### [ CLI ]

**AWS CLI**  
**Pour démarrer une tâche d’importation DICOM**  
L’exemple de code `start-dicom-import-job` suivant démarre une tâche d’importation DICOM.  

```
aws medical-imaging start-dicom-import-job \
    --job-name {{"my-job"}} \
    --datastore-id {{"12345678901234567890123456789012"}} \
    --input-s3-uri {{"s3://medical-imaging-dicom-input/dicom_input/"}} \
    --output-s3-uri {{"s3://medical-imaging-output/job_output/"}} \
    --data-access-role-arn {{"arn:aws:iam::123456789012:role/ImportJobDataAccessRole"}}
```
Sortie :  

```
{
    "datastoreId": "12345678901234567890123456789012",
    "jobId": "09876543210987654321098765432109",
    "jobStatus": "SUBMITTED",
    "submittedAt": "2022-08-12T11:28:11.152000+00:00"
}
```
Pour plus d'informations, consultez la section [Démarrage d'une tâche d'importation](https://docs.aws.amazon.com/healthimaging/latest/devguide/start-dicom-import-job.html) dans le *Guide du AWS HealthImaging développeur*.  
+  Pour plus de détails sur l'API, reportez-vous [StartDICOMImportJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/medical-imaging/start-dicom-import-job.html)à la section *Référence des AWS CLI commandes*. 

------
#### [ Java ]

**SDK pour Java 2.x**  

```
    public static String startDicomImportJob(MedicalImagingClient medicalImagingClient,
            String jobName,
            String datastoreId,
            String dataAccessRoleArn,
            String inputS3Uri,
            String outputS3Uri) {

        try {
            StartDicomImportJobRequest startDicomImportJobRequest = StartDicomImportJobRequest.builder()
                    .jobName(jobName)
                    .datastoreId(datastoreId)
                    .dataAccessRoleArn(dataAccessRoleArn)
                    .inputS3Uri(inputS3Uri)
                    .outputS3Uri(outputS3Uri)
                    .build();
            StartDicomImportJobResponse response = medicalImagingClient.startDICOMImportJob(startDicomImportJobRequest);
            return response.jobId();
        } catch (MedicalImagingException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }

        return "";
    }
```
+  Pour plus de détails sur l'API, reportez-vous [StartDICOMImportJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/medical-imaging-2023-07-19/StartDICOMImportJob)à la section *Référence des AWS SDK for Java 2.x API*. 
 Il y en a plus sur 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/medicalimaging#code-examples). 

------
#### [ JavaScript ]

**SDK pour JavaScript (v3)**  

```
import { StartDICOMImportJobCommand } from "@aws-sdk/client-medical-imaging";
import { medicalImagingClient } from "../libs/medicalImagingClient.js";

/**
 * @param {string} jobName - The name of the import job.
 * @param {string} datastoreId - The ID of the data store.
 * @param {string} dataAccessRoleArn - The Amazon Resource Name (ARN) of the role that grants permission.
 * @param {string} inputS3Uri - The URI of the S3 bucket containing the input files.
 * @param {string} outputS3Uri - The URI of the S3 bucket where the output files are stored.
 */
export const startDicomImportJob = async (
  jobName = "test-1",
  datastoreId = "12345678901234567890123456789012",
  dataAccessRoleArn = "arn:aws:iam::xxxxxxxxxxxx:role/ImportJobDataAccessRole",
  inputS3Uri = "s3://medical-imaging-dicom-input/dicom_input/",
  outputS3Uri = "s3://medical-imaging-output/job_output/",
) => {
  const response = await medicalImagingClient.send(
    new StartDICOMImportJobCommand({
      jobName: jobName,
      datastoreId: datastoreId,
      dataAccessRoleArn: dataAccessRoleArn,
      inputS3Uri: inputS3Uri,
      outputS3Uri: outputS3Uri,
    }),
  );
  console.log(response);
  // {
  //     '$metadata': {
  //     httpStatusCode: 200,
  //         requestId: '6e81d191-d46b-4e48-a08a-cdcc7e11eb79',
  //         extendedRequestId: undefined,
  //         cfId: undefined,
  //         attempts: 1,
  //         totalRetryDelay: 0
  // },
  //     datastoreId: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
  //     jobId: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
  //     jobStatus: 'SUBMITTED',
  //     submittedAt: 2023-09-22T14:48:45.767Z
  // }
  return response;
};
```
+  Pour plus de détails sur l'API, reportez-vous [StartDICOMImportJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/medical-imaging/command/StartDICOMImportJobCommand)à la section *Référence des AWS SDK pour JavaScript API*. 
 Il y en a plus sur 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/medical-imaging#code-examples). 

------
#### [ Python ]

**Kit SDK for Python (Boto3)**  

```
class MedicalImagingWrapper:
    def __init__(self, health_imaging_client):
        self.health_imaging_client = health_imaging_client


    def start_dicom_import_job(
        self, job_name, datastore_id, role_arn, input_s3_uri, output_s3_uri
    ):
        """
        Start a DICOM import job.

        :param job_name: The name of the job.
        :param datastore_id: The ID of the data store.
        :param role_arn: The Amazon Resource Name (ARN) of the role to use for the job.
        :param input_s3_uri: The S3 bucket input prefix path containing the DICOM files.
        :param output_s3_uri: The S3 bucket output prefix path for the result.
        :return: The job ID.
        """
        try:
            job = self.health_imaging_client.start_dicom_import_job(
                jobName=job_name,
                datastoreId=datastore_id,
                dataAccessRoleArn=role_arn,
                inputS3Uri=input_s3_uri,
                outputS3Uri=output_s3_uri,
            )
        except ClientError as err:
            logger.error(
                "Couldn't start DICOM import job. Here's why: %s: %s",
                err.response["Error"]["Code"],
                err.response["Error"]["Message"],
            )
            raise
        else:
            return job["jobId"]
```
Le code suivant instancie l' MedicalImagingWrapper objet.   

```
    client = boto3.client("medical-imaging")
    medical_imaging_wrapper = MedicalImagingWrapper(client)
```
+  Pour plus de détails sur l'API, consultez [StartDICOMImportJob](https://docs.aws.amazon.com/goto/boto3/medical-imaging-2023-07-19/StartDICOMImportJob)le *AWS manuel de référence de l'API SDK for Python (Boto3*). 
 Il y en a plus sur 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/medical-imaging#code-examples). 

------
#### [ SAP ABAP ]

**Kit SDK pour SAP ABAP**  

```
    TRY.
        " iv_job_name = 'import-job-1'
        " iv_datastore_id = '1234567890123456789012345678901234567890'
        " iv_role_arn = 'arn:aws:iam::123456789012:role/ImportJobRole'
        " iv_input_s3_uri = 's3://my-bucket/input/'
        " iv_output_s3_uri = 's3://my-bucket/output/'
        oo_result = lo_mig->startdicomimportjob(
          iv_jobname = iv_job_name
          iv_datastoreid = iv_datastore_id
          iv_dataaccessrolearn = iv_role_arn
          iv_inputs3uri = iv_input_s3_uri
          iv_outputs3uri = iv_output_s3_uri ).
        DATA(lv_job_id) = oo_result->get_jobid( ).
        MESSAGE |DICOM import job started with ID: { lv_job_id }.| TYPE 'I'.
      CATCH /aws1/cx_migaccessdeniedex.
        MESSAGE 'Access denied.' TYPE 'I'.
      CATCH /aws1/cx_migconflictexception.
        MESSAGE 'Conflict error.' TYPE 'I'.
      CATCH /aws1/cx_miginternalserverex.
        MESSAGE 'Internal server error.' TYPE 'I'.
      CATCH /aws1/cx_migresourcenotfoundex.
        MESSAGE 'Resource not found.' TYPE 'I'.
      CATCH /aws1/cx_migservicequotaexcdex.
        MESSAGE 'Service quota exceeded.' TYPE 'I'.
      CATCH /aws1/cx_migthrottlingex.
        MESSAGE 'Request throttled.' TYPE 'I'.
      CATCH /aws1/cx_migvalidationex.
        MESSAGE 'Validation error.' TYPE 'I'.
    ENDTRY.
```
+  Pour plus de détails sur l'API, consultez [StartDICOMImportJob](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*. 
 Il y en a plus sur 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/mig#code-examples). 

------

**Exemple de disponibilité**  
Vous n’avez pas trouvé ce dont vous avez besoin ? Demandez un exemple de code à l'aide du lien **Fournir des commentaires** dans la barre latérale droite de cette page.