Controllo dell'accesso con IAM

Questa pagina spiega come controllare l'accesso ai dispositivi utilizzando Identity and Access Management (IAM). L'accesso può essere concesso a livello di progetto o di registro. Non è disponibile alcun controllo dell'accesso a livello del singolo dispositivo. L'accesso viene generalmente concesso a una persona o a un gruppo di utenti o ad account di servizio lato server. I dispositivi utilizzano l'autenticazione tramite chiave pubblica/privata. Per ulteriori dettagli, consulta la sezione sulla sicurezza del dispositivo.

Ad esempio, se assegni a un utente il ruolo di cloudiot.provisioner a un criterio IAM del registro dispositivi, quest'ultimo potrà aggiungere o rimuovere dispositivi, ma non sarà in grado di modificare o eliminare il registro. Un ruolo può essere impostato anche su un progetto cloud e viene applicato a tutti i registry che lo appartengono.

Questa sezione si concentra sulle autorizzazioni IAM pertinenti per Cloud IoT Core e sui ruoli IAM che le concedono. Per una descrizione dettagliata di IAM e delle sue funzionalità, consulta la documentazione IAM. In particolare, consulta la sezione sulla gestione dei criteri IAM.

Ruoli

Un ruolo è un gruppo di autorizzazioni. Ad esempio, roles/cloudiot.viewer contiene le autorizzazioni cloudiot.registries.get, cloudiot.registries.list, cloudiot.devices.get e cloudiot.devices.list. Assegni ruoli a utenti o gruppi per consentire loro di eseguire azioni sui registry nel tuo progetto.

La tabella seguente elenca i ruoli IAM di Cloud IoT Core, incluse le autorizzazioni associate a ogni ruolo:

Ruolo Descrizione Autorizzazioni
roles/cloudiot.viewer Accesso in sola lettura a tutte le risorse Cloud IoT
  • cloudiot.registries.get
  • cloudiot.registries.list
  • cloudiot.devices.get
  • cloudiot.devices.list
roles/cloudiot.deviceController Accesso per aggiornare la configurazione dei dispositivi, ma non per creare o eliminare dispositivi Tutte le risposte precedenti e:
  • cloudiot.devices.updateConfig
  • cloudiot.devices.sendCommand
roles/cloudiot.provisioner Accesso per creare ed eliminare dispositivi dai registry, ma non per modificare i registry Tutte le risposte precedenti e:
  • cloudiot.devices.create
  • cloudiot.devices.delete
  • cloudiot.devices.update
roles/cloudiot.editor Accesso in lettura/scrittura a tutte le risorse Cloud IoT Tutte le risposte precedenti e:
  • cloudiot.registries.create
  • cloudiot.registries.delete
  • cloudiot.registries.update
roles/cloudiot.admin Controllo completo di tutte le autorizzazioni e le risorse di Cloud IoT Tutte le risposte precedenti e:
  • cloudiot.registries.getIamPolicy
  • cloudiot.registries.setIamPolicy

Un ruolo aggiuntivo, roles/cloudiot.serviceAgent, concede l'autorizzazione del publisher per gli argomenti Cloud Pub/Sub pertinenti. Questo ruolo viene assegnato automaticamente a un account di servizio creato quando attivi l'API Google Cloud IoT Core in un progetto. Nella maggior parte dei casi, non sarà necessario impostare o gestire questo ruolo. In caso di errori di autorizzazione relativi ad argomenti Cloud Pub/Sub, consulta la sezione Risoluzione dei problemi.

Per ulteriori informazioni sui ruoli, consulta Informazioni sui ruoli.

Autorizzazioni

Le autorizzazioni consentono agli utenti di eseguire azioni specifiche su registry o dispositivi in Cloud IoT Core. Ad esempio, l'autorizzazione cloudiot.registries.list consente a un utente di elencare i registry nel tuo progetto. Non devi concedere direttamente agli utenti le autorizzazioni, ma puoi assegnare loro dei ruoli che includono una o più autorizzazioni al loro interno. Puoi anche creare ruoli personalizzati.

Le seguenti tabelle elencano le autorizzazioni IAM associate a Cloud IoT Core:

Nome autorizzazione registro dispositivi Descrizione
cloudiot.registries.create Crea un nuovo registro in un progetto.
cloudiot.registries.delete Elimina un registro.
cloudiot.registries.get Leggere i dettagli del Registro di sistema, esclusi gli ACL.
cloudiot.registries.getIAMPolicy Lettura ACL del Registro di sistema.
cloudiot.registries.list Elenca i registry in un progetto.
cloudiot.registries.setIAMPolicy Aggiorna gli ACL del registro di sistema.
cloudiot.registries.update Aggiorna i dettagli del Registro di sistema, esclusi gli ACL.
cloudiot.devices.sendCommand Invia comandi (per registro, non per dispositivo).
Nome autorizzazione dispositivo Descrizione
cloudiot.devices.create Aggiungi un nuovo dispositivo a un registro.
cloudiot.devices.delete Eliminare un dispositivo.
cloudiot.devices.get Leggere i dettagli del dispositivo, esclusi gli ACL.
cloudiot.devices.list Elenca i dispositivi in un registro.
cloudiot.devices.update Aggiorna i dettagli del dispositivo, esclusi gli ACL.
cloudiot.devices.updateConfig Aggiorna la configurazione del dispositivo.
cloudiot.devices.bindGateway Associa un dispositivo a un gateway.
cloudiot.devices.unbindGateway Annulla l'associazione di un dispositivo da un gateway.

Per dettagli su quali autorizzazioni IAM consentono agli utenti di eseguire metodi su registry e dispositivi, consulta il riferimento REST specifico di ciascun metodo.

Gestione IAM di Cloud IoT Core

Puoi ottenere e impostare i criteri IAM utilizzando Google Cloud Console, l'API IAM o lo strumento gcloud. Per informazioni su come eseguire questa operazione a livello di progetto, consulta la sezione Concedere, modificare e revocare l'accesso. Il resto di questa sezione contiene informazioni sulla gestione IAM a livello di registro dei dispositivi.

Acquisisci una polizza

console

Per ottenere i controlli di accesso per un registro dispositivi:

  1. Vai alla pagina Registry in Google Cloud Console.

    Vai alla pagina Registry

  2. Seleziona la casella di controllo accanto al registro dispositivi per cui vuoi impostare le autorizzazioni. Se il riquadro informazioni non è aperto, fai clic su Mostra riquadro informazioni.

  3. Fai clic su Autorizzazioni. Viene visualizzato un riquadro Autorizzazioni con un elenco di utenti e le loro autorizzazioni.

gcloud

Per ricevere un criterio per il Registro di sistema dei dispositivi, esegui il comando gcloud iot registries get-iam-policy:

gcloud iot registries get-iam-policy REGISTRY_ID \
  --region=REGION \
  [--filter=EXPRESSION]
  [--limit=LIMIT]
  [--page-size=PAGE_SIZE]
  [--sort-by=[FIELD,...]]

API

Per ottenere le autorizzazioni IAM tramite l'API, utilizza il metodo DeviceRegistry getIamPolicy:

C#

public static object GetIamPolicy(string projectId, string cloudRegion, string registryId)
{
    var cloudIot = CreateAuthorizedClient();
    // The resource name of the location associated with the key rings.
    var parent = $"projects/{projectId}/locations/{cloudRegion}/registries/{registryId}";
    try
    {
        var req = new GetIamPolicyRequest();
        var result = cloudIot.Projects.Locations.Registries.GetIamPolicy(req, parent).Execute();
        Console.WriteLine("Bindings: ");
        if (result.Bindings != null)
        {
            result.Bindings.ToList().ForEach(binding =>
            {
                Console.WriteLine($"Role: {binding.Role}");
                binding.Members.ToList().ForEach(member =>
                {
                    Console.WriteLine($"\tMember: {member}");
                });
            });
        }
        else
        {
            Console.WriteLine($"\tNo IAM bindings for {registryId}.");
        }
    }
    catch (Google.GoogleApiException e)
    {
        Console.WriteLine(e.Message);
        return e.Error.Code;
    }
    return 0;
}

Go


// getRegistryIAM gets the IAM policy for a device registry.
func getRegistryIAM(w io.Writer, projectID string, region string, registryID string) (*cloudiot.Policy, error) {
	// Authorize the client using Application Default Credentials.
	// See https://g.co/dv/identity/protocols/application-default-credentials
	ctx := context.Background()
	httpClient, err := google.DefaultClient(ctx, cloudiot.CloudPlatformScope)
	if err != nil {
		return nil, err
	}
	client, err := cloudiot.New(httpClient)
	if err != nil {
		return nil, err
	}

	var req cloudiot.GetIamPolicyRequest

	path := fmt.Sprintf("projects/%s/locations/%s/registries/%s", projectID, region, registryID)
	response, err := client.Projects.Locations.Registries.GetIamPolicy(path, &req).Do()
	if err != nil {
		return nil, err
	}

	fmt.Fprintln(w, "Policy:")
	for _, binding := range response.Bindings {
		fmt.Fprintf(w, "Role: %s\n", binding.Role)
		for _, member := range binding.Members {
			fmt.Fprintf(w, "\tMember: %s\n", member)
		}
	}

	return response, nil
}

Java

/** Retrieves IAM permissions for the given registry. */
protected static void getIamPermissions(String projectId, String cloudRegion, String registryName)
    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 registryPath =
      String.format(
          "projects/%s/locations/%s/registries/%s", projectId, cloudRegion, registryName);

  com.google.api.services.cloudiot.v1.model.Policy policy =
      service
          .projects()
          .locations()
          .registries()
          .getIamPolicy(registryPath, new GetIamPolicyRequest())
          .execute();

  System.out.println("Policy ETAG: " + policy.getEtag());

  if (policy.getBindings() != null) {
    for (com.google.api.services.cloudiot.v1.model.Binding binding : policy.getBindings()) {
      System.out.println(String.format("Role: %s", binding.getRole()));
      System.out.println("Binding members: ");
      for (String member : binding.getMembers()) {
        System.out.println(String.format("\t%s", member));
      }
    }
  } else {
    System.out.println(String.format("No policy bindings for %s", registryName));
  }
}

Node.js

// const cloudRegion = 'us-central1';
// const projectId = 'adjective-noun-123';
// const registryId = 'my-registry';
const iot = require('@google-cloud/iot');

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

async function getIamPolicy() {
  // Construct request
  const formattedResource = iotClient.registryPath(
    projectId,
    cloudRegion,
    registryId
  );

  let bindings;
  const [response] = await iotClient.getIamPolicy({
    resource: formattedResource,
  });

  bindings = response.bindings;
  const etag = response.etag;

  console.log('ETAG:', etag);
  bindings = bindings || [];

  bindings.forEach(_binding => {
    console.log(`Role: ${_binding.role}`);
    _binding.members || (_binding.members = []);
    _binding.members.forEach(_member => {
      console.log(`\t${_member}`);
    });
  });
}

getIamPolicy();

PHP

use Google\Cloud\Iot\V1\DeviceManagerClient;

/**
 * Retrieves IAM permissions for the given registry.
 *
 * @param string $registryId IOT Device Registry ID
 * @param string $projectId Google Cloud project ID
 * @param string $location (Optional) Google Cloud region
 */
function get_iam_policy(
    $registryId,
    $projectId,
    $location = 'us-central1'
) {
    print('Getting IAM Policy' . PHP_EOL);

    // Instantiate a client.
    $deviceManager = new DeviceManagerClient();

    // Format the full registry path
    $registryName = $deviceManager->registryName($projectId, $location, $registryId);

    $policy = $deviceManager->getIamPolicy($registryName);

    print($policy->serializeToJsonString() . PHP_EOL);
}

Python

# project_id = 'YOUR_PROJECT_ID'
# cloud_region = 'us-central1'
# registry_id = 'your-registry-id'
client = iot_v1.DeviceManagerClient()

registry_path = client.registry_path(project_id, cloud_region, registry_id)

policy = client.get_iam_policy(request={"resource": registry_path})

return policy

Ruby

# project_id  = "Your Google Cloud project ID"
# location_id = "The Cloud region the registry is located in"
# registry_id = "The registry to get an IAM policy for"

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 resource name of the location associated with the project
parent   = "projects/#{project_id}/locations/#{location_id}"
resource = "#{parent}/registries/#{registry_id}"

# List the devices in the provided region
policy = iot_client.get_registry_iam_policy(
  resource
)

if policy.bindings
  policy.bindings.each do |binding|
    puts "Role: #{binding.role} Member: #{binding.members[0]}"
  end
else
  puts "No bindings"
end

Imposta un criterio

console

Per impostare i controlli di accesso a livello di registro dispositivi:

  1. Vai alla pagina Registry in Google Cloud Console.

    Vai alla pagina Registry

  2. Seleziona la casella di controllo accanto al registro dispositivi per cui vuoi impostare le autorizzazioni. Se il riquadro informazioni non è aperto, fai clic su Mostra riquadro informazioni.

  3. Fai clic su Autorizzazioni. Viene visualizzato un riquadro Autorizzazioni.

  4. Inserisci uno o più utenti, seleziona un ruolo dal menu a discesa e fai clic su Aggiungi.

gcloud

Per impostare un criterio per il Registro di sistema dei dispositivi, esegui il comando gcloud iot registries set-iam-policy:

gcloud iot registries set-iam-policy REGISTRY_ID \
  --region=REGION \
  POLICY_FILE

API

Per impostare le autorizzazioni IAM tramite l'API, utilizza il metodo DeviceRegistry setIamPolicy:

C#

public static object SetIamPolicy(string projectId, string cloudRegion, string registryId,
                                 string role, string member)
{
    var cloudIot = CreateAuthorizedClient();
    // The resource name of the location associated with the key rings.
    var parent = $"projects/{projectId}/locations/{cloudRegion}/registries/{registryId}";
    try
    {
        var req = new SetIamPolicyRequest();
        Policy pol = new Policy();
        pol.Bindings = new List<Binding>();
        Binding bind = new Binding()
        {
            Role = role,
            Members = new List<string>()
        };
        bind.Members.Add(member);
        pol.Bindings.Add(bind);

        req.Policy = pol;
        var result = cloudIot.Projects.Locations.Registries.SetIamPolicy(req, parent).Execute();
    }
    catch (Google.GoogleApiException e)
    {
        Console.WriteLine(e.Message);
        return e.Error.Code;
    }
    return 0;
}

Go


// setRegistryIAM sets the IAM policy for a device registry
func setRegistryIAM(w io.Writer, projectID string, region string, registryID string, member string, role string) (*cloudiot.Policy, error) {
	// Authorize the client using Application Default Credentials.
	// See https://g.co/dv/identity/protocols/application-default-credentials
	ctx := context.Background()
	httpClient, err := google.DefaultClient(ctx, cloudiot.CloudPlatformScope)
	if err != nil {
		return nil, err
	}
	client, err := cloudiot.New(httpClient)
	if err != nil {
		return nil, err
	}

	req := cloudiot.SetIamPolicyRequest{
		Policy: &cloudiot.Policy{
			Bindings: []*cloudiot.Binding{
				{
					Members: []string{member},
					Role:    role,
				},
			},
		},
	}
	path := fmt.Sprintf("projects/%s/locations/%s/registries/%s", projectID, region, registryID)
	response, err := client.Projects.Locations.Registries.SetIamPolicy(path, &req).Do()
	if err != nil {
		return nil, err
	}

	fmt.Fprintf(w, "Successfully set IAM policy for registry: %s\n", registryID)

	return response, nil
}

Java

/** Sets IAM permissions for the given registry. */
protected static void setIamPermissions(
    String projectId, String cloudRegion, String registryName, String member, String role)
    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 registryPath =
      String.format(
          "projects/%s/locations/%s/registries/%s", projectId, cloudRegion, registryName);

  com.google.api.services.cloudiot.v1.model.Policy policy =
      service
          .projects()
          .locations()
          .registries()
          .getIamPolicy(registryPath, new GetIamPolicyRequest())
          .execute();

  List<com.google.api.services.cloudiot.v1.model.Binding> bindings = policy.getBindings();

  boolean addNewRole = true;
  if (bindings != null) {
    for (com.google.api.services.cloudiot.v1.model.Binding binding : bindings) {
      if (binding.getRole().equals(role)) {
        List<String> members = binding.getMembers();
        members.add(member);
        binding.setMembers(members);
        addNewRole = false;
      }
    }
  } else {
    bindings = new ArrayList<>();
  }

  if (addNewRole) {
    com.google.api.services.cloudiot.v1.model.Binding bind =
        new com.google.api.services.cloudiot.v1.model.Binding();
    bind.setRole(role);
    List<String> members = new ArrayList<>();
    members.add(member);
    bind.setMembers(members);

    bindings.add(bind);
  }

  policy.setBindings(bindings);
  SetIamPolicyRequest req = new SetIamPolicyRequest().setPolicy(policy);

  policy = service.projects().locations().registries().setIamPolicy(registryPath, req).execute();

  System.out.println("Policy ETAG: " + policy.getEtag());
  for (com.google.api.services.cloudiot.v1.model.Binding binding : policy.getBindings()) {
    System.out.println(String.format("Role: %s", binding.getRole()));
    System.out.println("Binding members: ");
    for (String mem : binding.getMembers()) {
      System.out.println(String.format("\t%s", mem));
    }
  }
}

Node.js

// const cloudRegion = 'us-central1';
// const projectId = 'adjective-noun-123';
// const registryId = 'my-registry';

const iot = require('@google-cloud/iot');

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

async function setIamPolicy() {
  // Construct request
  const resource = iotClient.registryPath(projectId, cloudRegion, registryId);

  const policy = {
    bindings: [
      {
        members: [member],
        role: role,
      },
    ],
  };

  const request = {
    resource: resource,
    policy: policy,
  };

  let bindings;

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

  bindings = response.bindings;
  const etag = response.etag;

  console.log('ETAG:', etag);
  bindings = bindings || [];

  bindings.forEach(_binding => {
    console.log(`Role: ${_binding.role}`);
    _binding.members || (_binding.members = []);
    _binding.members.forEach(_member => {
      console.log(`\t${_member}`);
    });
  });
}

setIamPolicy();

PHP

use Google\Cloud\Iot\V1\DeviceManagerClient;
use Google\Cloud\Iam\V1\Policy;
use Google\Cloud\Iam\V1\Binding;

/**
 * Sets IAM permissions for the given registry to a single role/member.
 *
 * @param string $registryId IOT Device Registry ID
 * @param string $role Role used for IAM commands
 * @param string $member Member used for IAM commands
 * @param string $projectId Google Cloud project ID
 * @param string $location (Optional) Google Cloud region
 */
function set_iam_policy(
    $registryId,
    $role,
    $member,
    $projectId,
    $location = 'us-central1'
) {
    print('Setting IAM policy' . PHP_EOL);

    // Instantiate a client.
    $deviceManager = new DeviceManagerClient();
    $registryName = $deviceManager->registryName($projectId, $location, $registryId);

    $binding = (new Binding())
        ->setMembers([$member])
        ->setRole($role);

    $policy = (new Policy())
        ->setBindings([$binding]);

    $policy = $deviceManager->setIamPolicy($registryName, $policy);

    print($policy->serializeToJsonString() . PHP_EOL);
}

Python

# project_id = 'YOUR_PROJECT_ID'
# cloud_region = 'us-central1'
# registry_id = 'your-registry-id'
# role = 'viewer'
# member = 'group:dpebot@google.com'
client = iot_v1.DeviceManagerClient()
registry_path = client.registry_path(project_id, cloud_region, registry_id)

body = {"bindings": [{"members": [member], "role": role}]}

return client.set_iam_policy(request={"resource": registry_path, "policy": body})

Ruby

# project_id  = "Your Google Cloud project ID"
# location_id = "The Cloud region the registry is located in"
# registry_id = "The registry to set an IAM policy for"
# member      = "The member to add to the policy bindings"
# role        = "The role for the binding the policy is set to"

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 resource name of the location associated with the project
parent   = "projects/#{project_id}/locations/#{location_id}"
resource = "#{parent}/registries/#{registry_id}"

request = Google::Apis::CloudiotV1::SetIamPolicyRequest.new
policy  = Google::Apis::CloudiotV1::Policy.new
binding = Google::Apis::CloudiotV1::Binding.new
binding.members = [member]
binding.role    = role
policy.bindings = [binding]
request.policy  = policy

# List the devices in the provided region
result = iot_client.set_registry_iam_policy(
  resource, request
)

if result.bindings
  puts "Binding set:"
  result.bindings.each do |binding|
    puts "\tRole: #{binding.role} Member: #{binding.members[0]}"
  end
else
  puts "No bindings"
end