Autenticazione delle applicazioni

Questa pagina spiega come utilizzare gli account di servizio gestiti dall'utente e le relative chiavi private per autenticare un'applicazione nell'API Cloud IoT Core.

Puoi utilizzare applicazioni per amministrare registry e dispositivi. Ad esempio, vedi gli esempi di codice di Cloud IoT Core.

Autenticazione mediante account di servizio

Un account di servizio gestito dall'utente è un tipo di Account Google che rappresenta un'applicazione. Gli account di servizio gestiti dall'utente vengono utilizzati principalmente per l'autenticazione da server a API.

Cloud IoT Core utilizza due tipi di autenticazione. Per autenticare i dispositivi in Cloud IoT Core, utilizzi coppie di chiavi private/pubbliche e JSON Web Token. Tuttavia, quando autentichi un'applicazione all'API Cloud IoT Core, devi utilizzare l'autenticazione GCP sotto forma di account di servizio gestiti dall'utente.

Gli account di servizio gestiti dagli utenti hanno chiavi private, disponibili in vari formati. Fornendo una chiave privata di un account di servizio gestito dall'utente a un'applicazione, puoi creare credenziali e autenticare l'applicazione.

Per autenticare le applicazioni ti consigliamo di utilizzare gli account di servizio gestiti dall'utente e le chiavi JSON private, che sono i metodi più ampiamente supportati e flessibili. Puoi creare un account di servizio gestito dall'utente e scaricare una chiave JSON privata completando i passaggi descritti in Guida introduttiva all'autenticazione.

I seguenti esempi mostrano come utilizzare una chiave JSON privata di un account di servizio gestito dall'utente per autenticare un'applicazione nell'API Cloud IoT Core:

C#

Tieni presente che l'esempio C# non specifica in modo esplicito un file di chiave JSON, ma utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali in modo implicito.
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

Tieni presente che l'esempio Go non specifica in modo esplicito un file di chiave JSON, ma utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali in modo implicito. L'esempio viene utilizzato anche nel contesto della creazione di un registro, ma di seguito è evidenziata l'autenticazione effettiva.

// 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

Tieni presente che l'esempio Java non specifica esplicitamente un file di chiave JSON, ma utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali in modo implicito. L'esempio viene utilizzato anche nel contesto della creazione di un registro, ma di seguito è evidenziata l'autenticazione effettiva.
/** 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 = JacksonFactory.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

// 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

Tieni presente che l'esempio PHP non specifica in modo esplicito un file di chiave JSON, ma utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali in modo implicito. L'esempio viene utilizzato anche nel contesto della creazione di un registro, ma di seguito è evidenziata l'autenticazione effettiva.
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

Tieni presente che l'esempio Python non specifica in modo esplicito un file di chiave JSON, ma utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali in modo implicito.
# 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

Tieni presente che l'esempio di Ruby non specifica in modo esplicito un file di chiave JSON, ma utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali in modo implicito. L'esempio viene utilizzato anche nel contesto della creazione di un registro, ma di seguito è evidenziata l'autenticazione effettiva.
# 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}"