Authentifier des applications

Cette page explique comment utiliser les comptes de service gérés par l'utilisateur et leurs clés privées pour authentifier une application auprès de l'API Cloud IoT Core.

Vous pouvez utiliser des applications pour administrer les registres et les appareils. Pour obtenir des exemples, consultez les exemples de code Cloud IoT Core.

Authentification à l'aide de comptes de service

Un compte de service géré par l'utilisateur est un type de compte Google qui représente une application. Les comptes de service gérés par l'utilisateur sont principalement utilisés pour l'authentification de serveur à API.

Remarque :Cette page ne décrit pas les comptes de service créés et détenus par Google pour gérer les rôles et les autorisations des différents services. Par exemple, lorsque vous activez pour la première fois l'API Cloud IoT Core pour un projet, un nouveau compte de service se voit automatiquement attribuer un rôle permettant la publication dans des sujets Pub/Sub. Pour en savoir plus, consultez Créer un registre d'appareils.

Cloud IoT Core utilise deux types d'authentification. Pour authentifier des appareils auprès de Cloud IoT Core, vous devez utiliser des paires de clés publiques/privées et des jetons Web JSON. Toutefois, lorsque vous authentifiez une application auprès de l'API Cloud IoT Core, vous devez utiliser l'authentification GCP sous la forme de comptes de service gérés par l'utilisateur.

Les comptes de service gérés par l'utilisateur possèdent leurs propres clés privées, qui se présentent sous différents formats. En fournissant la clé privée d'un compte de service géré par l'utilisateur à une application, vous pouvez créer des identifiants et authentifier l'application.

La méthode recommandée pour authentifier les applications consiste à utiliser des comptes de service gérés par l'utilisateur et des clés JSON privées, car il s'agit des méthodes les plus courantes et les plus flexibles. Vous pouvez créer un compte de service géré par l'utilisateur et télécharger une clé JSON privée en suivant la procédure décrite dans Premiers pas avec l'authentification.

Les exemples suivants montrent comment utiliser la clé JSON privée d'un compte de service géré par l'utilisateur pour authentifier une application sur l'API Cloud IoT Core :

C#

Notez que l'exemple C# ne spécifie pas explicitement un fichier de clé JSON. Il utilise l'emplacement spécifié dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. La bibliothèque cliente peut ensuite déterminer les identifiants implicitement.

Afficher sur GitHub Commentaires

public static CloudIotService CreateAuthorizedClient()
{
    GoogleCredential credential =
        GoogleCredential.GetApplicationDefaultAsync().Result;
    // Inject the Cloud IoT Core Service scope
    if (credential.IsCreateScopedRequired)
    {
        credential = credential.CreateScoped(new[]
        {
            CloudIotService.Scope.CloudPlatform // Used for IoT + PubSub + IAM
            //CloudIotService.Scope.Cloudiot // Can be used if not accessing Pub/Sub
        });
    }
    return new CloudIotService(new BaseClientService.Initializer
    {
        HttpClientInitializer = credential,
        GZipEnabled = false
    });
}

Go

Notez que l'exemple Go ne spécifie pas explicitement un fichier de clé JSON. Il utilise l'emplacement spécifié dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. La bibliothèque cliente peut ensuite déterminer les identifiants implicitement. L'exemple est également utilisé dans le contexte de la création d'un registre, mais l'authentification réelle est mise en évidence ci-dessous.

Afficher sur GitHub Commentaires

// createRegistry creates a IoT Core device registry associated with a PubSub topic
func createRegistry(w io.Writer, projectID string, region string, registryID string, topicName string) (*cloudiot.DeviceRegistry, error) {
	client, err := getClient()
	if err != nil {
		return nil, err
	}

	registry := cloudiot.DeviceRegistry{
		Id: registryID,
		EventNotificationConfigs: []*cloudiot.EventNotificationConfig{
			{
				PubsubTopicName: topicName,
			},
		},
	}

	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)
	response, err := client.Projects.Locations.Registries.Create(parent, &registry).Do()
	if err != nil {
		return nil, err
	}

	fmt.Fprintln(w, "Created registry:")
	fmt.Fprintf(w, "\tID: %s\n", response.Id)
	fmt.Fprintf(w, "\tHTTP: %s\n", response.HttpConfig.HttpEnabledState)
	fmt.Fprintf(w, "\tMQTT: %s\n", response.MqttConfig.MqttEnabledState)
	fmt.Fprintf(w, "\tName: %s\n", response.Name)

	return response, nil
}

Java

Notez que l'exemple Java ne spécifie pas explicitement un fichier de clé JSON. Il utilise l'emplacement spécifié dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. La bibliothèque cliente peut ensuite déterminer les identifiants implicitement. L'exemple est également utilisé dans le contexte de la création d'un registre, mais l'authentification réelle est mise en évidence ci-dessous.

Afficher sur GitHub Commentaires

/** Create a registry for Cloud IoT. */
protected static void createRegistry(
    String cloudRegion, String projectId, String registryName, String pubsubTopicPath)
    throws GeneralSecurityException, IOException {
  GoogleCredentials credential =
      GoogleCredentials.getApplicationDefault().createScoped(CloudIotScopes.all());
  JsonFactory jsonFactory = GsonFactory.getDefaultInstance();
  HttpRequestInitializer init = new HttpCredentialsAdapter(credential);
  final CloudIot service =
      new CloudIot.Builder(GoogleNetHttpTransport.newTrustedTransport(), jsonFactory, init)
          .setApplicationName(APP_NAME)
          .build();

  final String projectPath = "projects/" + projectId + "/locations/" + cloudRegion;
  final String fullPubsubPath = "projects/" + projectId + "/topics/" + pubsubTopicPath;

  DeviceRegistry registry = new DeviceRegistry();
  EventNotificationConfig notificationConfig = new EventNotificationConfig();
  notificationConfig.setPubsubTopicName(fullPubsubPath);
  List<EventNotificationConfig> notificationConfigs = new ArrayList<EventNotificationConfig>();
  notificationConfigs.add(notificationConfig);
  registry.setEventNotificationConfigs(notificationConfigs);
  registry.setId(registryName);

  DeviceRegistry reg =
      service.projects().locations().registries().create(projectPath, registry).execute();
  System.out.println("Created registry: " + reg.getName());
}

Node.js

Afficher sur GitHub Commentaires

// Client retrieved in callback
// const cloudRegion = 'us-central1';
// const projectId = 'adjective-noun-123';
// const registryId = 'my-registry';
// function errCb = lookupRegistry; // Lookup registry if already exists.
const iot = require('@google-cloud/iot');

// Lookup the pubsub topic
const topicPath = `projects/${projectId}/topics/${pubsubTopicId}`;

const iotClient = new iot.v1.DeviceManagerClient({
  // optional auth parameters.
});

async function createDeviceRegistry() {
  // Construct request
  const newParent = iotClient.locationPath(projectId, cloudRegion);
  const deviceRegistry = {
    eventNotificationConfigs: [
      {
        pubsubTopicName: topicPath,
      },
    ],
    id: registryId,
  };
  const request = {
    parent: newParent,
    deviceRegistry: deviceRegistry,
  };

  const [response] = await iotClient.createDeviceRegistry(request);

  console.log('Successfully created registry');
  console.log(response);
}

createDeviceRegistry();

PHP

Notez que l'exemple PHP ne spécifie pas explicitement un fichier de clé JSON. Il utilise l'emplacement spécifié dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. La bibliothèque cliente peut ensuite déterminer les identifiants implicitement. L'exemple est également utilisé dans le contexte de la création d'un registre, mais l'authentification réelle est mise en évidence ci-dessous.

Afficher sur GitHub Commentaires

use Google\Cloud\Iot\V1\DeviceManagerClient;

/**
 * List all registries in the project.
 *
 * @param string $projectId Google Cloud project ID
 * @param string $location (Optional) Google Cloud region
 */
function list_registries(
    $projectId,
    $location = 'us-central1'
) {
    print('Listing Registries' . PHP_EOL);

    // The Google Cloud Client Library automatically checks the environment
    // variable GOOGLE_APPLICATION_CREDENTIALS for the Service Account
    // credentials, and defaults scopes to [
    //    'https://www.googleapis.com/auth/cloud-platform',
    //    'https://www.googleapis.com/auth/cloudiot'
    // ].
    $deviceManager = new DeviceManagerClient();
    $locationName = $deviceManager->locationName($projectId, $location);

    $response = $deviceManager->listDeviceRegistries($locationName);

    foreach ($response->iterateAllElements() as $registry) {
        printf(' - Id: %s, Name: %s' . PHP_EOL,
            $registry->getId(),
            $registry->getName());
    }
}

Python

Notez que l'exemple Python ne spécifie pas explicitement un fichier de clé JSON. Il utilise l'emplacement spécifié dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. La bibliothèque cliente peut ensuite déterminer les identifiants implicitement.

Afficher sur GitHub Commentaires

# project_id = 'YOUR_PROJECT_ID'
# cloud_region = 'us-central1'
# pubsub_topic = 'your-pubsub-topic'
# registry_id = 'your-registry-id'
client = iot_v1.DeviceManagerClient()
parent = f"projects/{project_id}/locations/{cloud_region}"

if not pubsub_topic.startswith("projects/"):
    pubsub_topic = "projects/{}/topics/{}".format(project_id, pubsub_topic)

body = {
    "event_notification_configs": [{"pubsub_topic_name": pubsub_topic}],
    "id": registry_id,
}

try:
    response = client.create_device_registry(
        request={"parent": parent, "device_registry": body}
    )
    print("Created registry")
    return response
except HttpError:
    print("Error, registry not created")
    raise
except AlreadyExists:
    print("Error, registry already exists")
    raise

Ruby

Notez que l'exemple Ruby ne spécifie pas explicitement un fichier de clé JSON. Il utilise l'emplacement spécifié dans la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. La bibliothèque cliente peut ensuite déterminer les identifiants implicitement. L'exemple est également utilisé dans le contexte de la création d'un registre, mais l'authentification réelle est mise en évidence ci-dessous.

Afficher sur GitHub Commentaires

# project_id   = "Your Google Cloud project ID"
# location_id  = "The Cloud region that you created the registry in"
# registry_id  = "The Google Cloud IoT Core device registry identifier"
# pubsub_topic = "The Google Cloud PubSub topic to use for this registry"

require "google/apis/cloudiot_v1"

# Initialize the client and authenticate with the specified scope
Cloudiot   = Google::Apis::CloudiotV1
iot_client = Cloudiot::CloudIotService.new
iot_client.authorization = Google::Auth.get_application_default(
  "https://www.googleapis.com/auth/cloud-platform"
)

# The project / location where the registry is created.
parent = "projects/#{project_id}/locations/#{location_id}"

registry = Cloudiot::DeviceRegistry.new
registry.id = registry_id
registry.event_notification_configs = [Cloudiot::EventNotificationConfig.new]
registry.event_notification_configs[0].pubsub_topic_name = pubsub_topic

registry = iot_client.create_project_location_registry(
  parent, registry
)

puts "Created registry: #{registry.name}"