Google Cloud IoT Core verrà ritirato il 16 agosto 2023. Per saperne di più, contatta il team dedicato al tuo account Google Cloud.

Autenticazione delle applicazioni

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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 le applicazioni per amministrare i registry e i dispositivi. Per alcuni esempi, vedi gli esempi di codice di Cloud IoT Core.

Autenticazione tramite 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. Quando autentichi i dispositivi a Cloud IoT Core, utilizzi coppie di chiavi pubbliche/private e token web JSON. Quando autentichi un'applicazione all'API Cloud IoT Core, tuttavia, devi utilizzare l'autenticazione GCP sotto forma di account di servizio gestiti dall'utente.

Gli account di servizio gestiti dall'utente hanno le proprie chiavi private, disponibili in vari formati. Se fornisci la chiave privata di un account di servizio gestito dall'utente a un'applicazione, puoi creare credenziali e autenticare l'applicazione.

Il metodo consigliato per autenticare le applicazioni è utilizzare account di servizio gestiti dall'utente e chiavi JSON private, poiché sono i metodi più supportati e flessibili. Puoi creare un account di servizio gestito dall'utente e scaricare una chiave JSON privata completando i passaggi descritti nella Guida introduttiva all'autenticazione.

Gli esempi riportati di seguito mostrano come utilizzare la 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 esplicitamente un file di chiave JSON, bensì si serve della località specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali implicitamente.
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 di Go non specifica in modo esplicito un file di chiave JSON, bensì utilizza la posizione specificata nella variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. La libreria client può quindi determinare le credenziali implicitamente. L'esempio viene utilizzato anche nel contesto della creazione di un registro, ma l'autenticazione effettiva viene evidenziata di seguito.

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