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

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 di singolo dispositivo. L'accesso è in genere concesso a una persona o a un gruppo di utenti o agli account di servizio lato server. I dispositivi utilizzano l'autenticazione con chiave pubblica/privata. Per maggiori dettagli, consulta la sezione sulla sicurezza dei dispositivi.

Ad esempio, se assegni a un utente il ruolo di cloudiot.provisioner a un criterio IAM del registro dispositivi, l'utente potrà aggiungere o rimuovere i dispositivi, ma non potrà modificare o eliminare il registro stesso. È possibile impostare un ruolo anche su un progetto cloud; viene applicato a tutti i registri appartenenti a tale progetto cloud.

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 di IAM. In particolare, consulta la sezione sulla gestione dei criteri IAM.

Ruoli

Un ruolo è un pacchetto di autorizzazioni. Ad esempio, roles/cloudiot.viewer contiene le autorizzazioni cloudiot.registries.get, cloudiot.registries.list, cloudiot.devices.get e cloudiot.devices.list. Assegna 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 ciascun ruolo:

Ruolo Descrizione Autorizzazioni
roles/cloudiot.viewer Accesso in sola lettura a tutte le risorse di 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 registri, ma non per modificarli 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 di Cloud IoT Tutte le risposte precedenti e:
  • cloudiot.registries.create
  • cloudiot.registries.delete
  • cloudiot.registries.update
roles/cloudiot.admin Controllo completo di tutte le risorse e le autorizzazioni di Cloud IoT Tutte le risposte precedenti e:
  • cloudiot.registries.getIamPolicy
  • cloudiot.registries.setIamPolicy

Un ruolo aggiuntivo, roles/cloudiot.serviceAgent, concede l'autorizzazione di 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. Se si verificano errori di autorizzazione relativi agli argomenti di Cloud Pub/Sub, consulta la sezione Risoluzione dei problemi.

Per ulteriori informazioni sui ruoli, vedi 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 registri nel tuo progetto. Non devi concedere direttamente agli utenti le autorizzazioni, ma assegnarli ai ruoli, i quali dispongono di una o più autorizzazioni raggruppate al loro interno. Puoi anche creare ruoli personalizzati.

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

Nome autorizzazione del registro dei dispositivi Descrizione
cloudiot.registries.create Crea un nuovo registro in un progetto.
cloudiot.registries.delete Eliminare un registro.
cloudiot.registries.get Lettura dei dettagli del Registro di sistema, esclusi gli ACL.
cloudiot.registries.getIAMPolicy Lettura degli 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 Associare un dispositivo a un gateway.
cloudiot.devices.unbindGateway Svincola un dispositivo da un gateway.

Per maggiori dettagli sulle autorizzazioni IAM che consentono agli utenti di eseguire metodi su registry e dispositivi, consulta il riferimento REST specifico per ogni metodo.

Gestione IAM di Cloud IoT Core

Puoi ottenere e impostare i criteri IAM utilizzando la console Google Cloud, l'API IAM o lo strumento gcloud. Per informazioni su come farlo a livello di progetto, consulta la pagina Concessione, modifica e revoca dell'accesso. Il resto di questa sezione contiene informazioni sulla gestione IAM a livello di registry del dispositivo.

Acquisisci una polizza

Console

Per ottenere i controlli di accesso per un registro di dispositivi:

  1. Vai alla pagina Registry nella console Google Cloud.

    Vai alla pagina Registry

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

  3. Fai clic su Autorizzazioni. Si apre un riquadro Autorizzazioni contenente un elenco di utenti e le relative autorizzazioni.

gcloud

Per ricevere un criterio per un registro 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, utilizzare 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 = GsonFactory.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 dell'accesso a livello di registro dei dispositivi:

  1. Vai alla pagina Registry nella console Google Cloud.

    Vai alla pagina Registry

  2. Seleziona la casella di controllo accanto al registro di 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 un registro 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, usa 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 = GsonFactory.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