将 RSA256 身份验证添加到设备中。
深入探索
如需查看包含此代码示例的详细文档，请参阅以下内容：
代码示例
Go
如需了解详情，请参阅 Cloud IoT Core Go API 参考文档。
如需向 Cloud IoT Core 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
// patchDeviceRSA patches a device to use RSA256 X.509 credentials.
func patchDeviceRSA(w io.Writer, projectID string, region string, registryID string, deviceID string, keyPath string) (*cloudiot.Device, 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
}
keyBytes, err := ioutil.ReadFile(keyPath)
if err != nil {
return nil, err
}
device := cloudiot.Device{
Id: deviceID,
Credentials: []*cloudiot.DeviceCredential{
{
PublicKey: &cloudiot.PublicKeyCredential{
Format: "RSA_X509_PEM",
Key: string(keyBytes),
},
},
},
}
parent := fmt.Sprintf("projects/%s/locations/%s/registries/%s/devices/%s", projectID, region, registryID, deviceID)
response, err := client.Projects.Locations.Registries.Devices.
Patch(parent, &device).UpdateMask("credentials").Do()
if err != nil {
return nil, err
}
fmt.Fprintln(w, "Successfully patched device with RSA256 X.509 credentials")
return response, nil
}
Java
如需了解详情，请参阅 Cloud IoT Core Java API 参考文档。
如需向 Cloud IoT Core 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
/** Patch the device to add an RSA256 key for authentication. */
protected static void patchRsa256ForAuth(
String deviceId,
String publicKeyFilePath,
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 devicePath =
String.format(
"projects/%s/locations/%s/registries/%s/devices/%s",
projectId, cloudRegion, registryName, deviceId);
PublicKeyCredential publicKeyCredential = new PublicKeyCredential();
String key = Files.asCharSource(new File(publicKeyFilePath), StandardCharsets.UTF_8).read();
publicKeyCredential.setKey(key);
publicKeyCredential.setFormat("RSA_X509_PEM");
DeviceCredential devCredential = new DeviceCredential();
devCredential.setPublicKey(publicKeyCredential);
Device device = new Device();
device.setCredentials(Collections.singletonList(devCredential));
Device patchedDevice =
service
.projects()
.locations()
.registries()
.devices()
.patch(devicePath, device)
.setUpdateMask("credentials")
.execute();
System.out.println("Patched device is " + patchedDevice.toPrettyString());
}Node.js
如需了解详情，请参阅 Cloud IoT Core Node.js API 参考文档。
如需向 Cloud IoT Core 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
// const cloudRegion = 'us-central1';
// const deviceId = 'my-rsa-device';
// 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 updateDevice() {
// Construct request
const devPath = iotClient.devicePath(
projectId,
cloudRegion,
registryId,
deviceId
);
const device = {
name: devPath,
credentials: [
{
publicKey: {
format: 'RSA_X509_PEM',
key: readFileSync(rsaPublicKeyFile).toString(),
},
},
],
};
const [response] = await iotClient.updateDevice({
device: device,
updateMask: {paths: ['credentials']},
});
console.log('Patched device:', deviceId);
console.log('Response', response);
}
updateDevice();PHP
如需了解详情，请参阅 Cloud IoT Core PHP API 参考文档。
如需向 Cloud IoT Core 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
use Google\Cloud\Iot\V1\DeviceManagerClient;
use Google\Cloud\Iot\V1\Device;
use Google\Cloud\Iot\V1\DeviceCredential;
use Google\Cloud\Iot\V1\PublicKeyCredential;
use Google\Cloud\Iot\V1\PublicKeyFormat;
use Google\Protobuf\FieldMask;
/**
* Patch the device to add an RSA256 public key to the device.
*
* @param string $registryId IOT Device Registry ID
* @param string $deviceId IOT Device ID
* @param string $certificateFile Path to RS256 certificate file.
* @param string $projectId Google Cloud project ID
* @param string $location (Optional) Google Cloud region
*/
function patch_rsa(
$registryId,
$deviceId,
$certificateFile,
$projectId,
$location = 'us-central1'
) {
print('Patch device with RSA256 certificate' . PHP_EOL);
// Instantiate a client.
$deviceManager = new DeviceManagerClient();
$deviceName = $deviceManager->deviceName($projectId, $location, $registryId, $deviceId);
$publicKey = (new PublicKeyCredential())
->setFormat(PublicKeyFormat::RSA_X509_PEM)
->setKey(file_get_contents($certificateFile));
$credential = (new DeviceCredential())
->setPublicKey($publicKey);
$device = (new Device())
->setName($deviceName)
->setCredentials([$credential]);
$updateMask = (new FieldMask())
->setPaths(['credentials']);
$device = $deviceManager->updateDevice($device, $updateMask);
printf('Updated device %s' . PHP_EOL, $device->getName());
}Python
如需了解详情，请参阅 Cloud IoT Core Python API 参考文档。
如需向 Cloud IoT Core 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
# project_id = 'YOUR_PROJECT_ID'
# cloud_region = 'us-central1'
# registry_id = 'your-registry-id'
# device_id = 'your-device-id'
# public_key_file = 'path/to/certificate.pem'
print("Patch device with RSA256 certificate")
client = iot_v1.DeviceManagerClient()
device_path = client.device_path(project_id, cloud_region, registry_id, device_id)
public_key_bytes = ""
with io.open(public_key_file) as f:
public_key_bytes = f.read()
key = iot_v1.PublicKeyCredential(
format=iot_v1.PublicKeyFormat.RSA_X509_PEM, key=public_key_bytes
)
cred = iot_v1.DeviceCredential(public_key=key)
device = client.get_device(request={"name": device_path})
device.id = b""
device.num_id = 0
device.credentials.append(cred)
mask = gp_field_mask.FieldMask()
mask.paths.append("credentials")
return client.update_device(request={"device": device, "update_mask": mask})
Ruby
如需了解详情，请参阅 Cloud IoT Core Ruby API 参考文档。
如需向 Cloud IoT Core 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。
# project_id = "Your Google Cloud project ID"
# location_id = "The Cloud region the registry is located in"
# registry_id = "The registry to create a device in"
# device_id = "The identifier of the device to patch"
# cert_path = "The path to the RSA certificate"
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}/registries/#{registry_id}"
path = "#{parent}/devices/#{device_id}"
credential = Google::Apis::CloudiotV1::DeviceCredential.new
credential.public_key = Google::Apis::CloudiotV1::PublicKeyCredential.new
credential.public_key.format = "RSA_X509_PEM"
credential.public_key.key = File.read cert_path
device = Cloudiot::Device.new
device.credentials = [credential]
# Create the device
device = iot_client.patch_project_location_registry_device(
path, device, update_mask: "credentials"
)
puts "Device: #{device.id}"
puts "\tBlocked: #{device.blocked}"
puts "\tLast Event Time: #{device.last_event_time}"
puts "\tLast State Time: #{device.last_state_time}"
puts "\tName: #{device.name}"
puts "\tCertificate formats:"
if device.credentials
device.credentials.each { |cert| puts "\t\t#{cert.public_key.format}" }
else
puts "\t\tNo certificates for device"
end后续步骤
如需搜索并过滤其他 Google Cloud 产品的代码示例，请参阅 Google Cloud 示例浏览器。