Compare to some other cloud providers, creating an identity via code in GCP is a little fragmented if your using GSuite for your identity storage. The Google Cloud Platform holds your users identity reference and permission, while the other system GSuite hold the security of the users authentication. This can also make the documentation feel a little fragmented and not so easy to follow. Hence this post to stick them together in how I used C# Dot Net Core to create a Google Cloud Platform Identity using their SDK.
This part is standard for any SDK access to GCP, which is to have a service account authentication. For this you will need to create a Service Account in GCP, which needs to be associated with a project. You can create it against the project where you are deploying, or to keep things separate, like I would recommend, you can create a Service Management Project. This is just a standard project, but you can use this to keep all the SDK activity on this project while the usage activity happens on the other project.
Create a Project
- Go to the Manage resources page in the Cloud Console.
- On the Select organization drop-down list at the top of the page, select the organization in which you want to create a project. If you are a free trial user, skip this step, as this list does not appear.
- Click Create Project.
- In the New Project window that appears, enter a project name and select a billing account as applicable. A project name can contain only letters, numbers, single quotes, hyphens, spaces, or exclamation points, and must be between 4 and 30 characters.
- Enter the parent organization or folder in the Location box. That resource will be the hierarchical parent of the new project.
- When you’re finished entering new project details, click Create.
Reference: https://cloud.google.com/resource-manager/docs/creating-managing-projects#console
Create a Service Account
- In the Cloud Console, go to the Service accounts page.
- Select a project (your new Service Management Project).
- Click Create service account.
- Enter a service account name to display in the Cloud Console.
The Cloud Console generates a service account ID based on this name. Edit the ID if necessary. You cannot change the ID later. - Optional: Enter a description of the service account.
- If you do not want to set access controls now, click Done to finish creating the service account.
To set access controls now, click Create and continue to the next step. - Optional: Choose one or more IAM roles to grant to the service account on the project.
- When you are done adding roles, click Continue.
- Optional: In the Service account users role field, add members that can impersonate the service account.
- Optional: In the Service account admins role field, add members that can manage the service account.
- Click Done to finish creating the service account.
You could then get more specific for the Identity Access Management (IAM) permissions, but to keep it simple you would just need to apply the Service Account ‘Owner’ and ‘Project IAM Admin’ access on the new Service Management Project. This will give the Service Account access to create the identities, but for more detail on the permissions, you can use this link to look them up. https://cloud.google.com/iam/docs/permissions-reference
Next we need the Service Account to have access to create the identities in the GSuite. The below sets the Service Account in GCP ready to give access in the Admin portal of GSuite.
- Locate the newly-created service account in the table. Under Actions, click more the 3 dots at the end, then Edit.
- In the service account details, click the down arrow to see more Show domain-wide delegation, then ensure the Enable G Suite Domain-wide Delegation checkbox is checked.
- If you haven’t yet configured your app’s OAuth consent screen, you must do so before you can enable domain-wide delegation. Follow the on-screen instructions to configure the OAuth consent screen, then repeat the above steps and re-check the checkbox.
- Click Save to update the service account, and return to the table of service accounts. A new column, Domain-wide delegation, can be seen. Click View Client ID, to obtain and make a note of the client ID.
Now we connect these together, but giving the Service Account access in the GSuite Admin Portal.
- From your Google Workspace domain’s Admin console, go to Main menu menu> Security > API controls.
- In the Domain wide delegation pane, select Manage Domain Wide Delegation.
- Click Add new.
- In the Client ID field, enter the client ID obtained from the service account creation steps above.
- In the OAuth Scopes field, enter a comma-delimited list of the scopes required for your application (for a list of possible scopes, see Authorize requests).
For example, if you require domain-wide access to Users and Groups enter: https://www.googleapis.com/auth/admin.directory.user, https://www.googleapis.com/auth/admin.directory.group - Click Authorize.
At this point our Service Account has access to the GCP Account/Project and also has the access needed for the GSuite to create the identities. Therefore, we can start getting into the code to create these accounts.
To start with the SDK we need the Service Accounts JSON Key, which you can get by:
- In the Cloud Console, go to the Service Accounts page.
- Click Select a project, choose a project, and click Open.
- Find the row of the service account that you want to create a key for. In that row, click the More button, and then click Create key.
- Select a Key type and click Create.
Once you have downloaded the JSON File we can move to the Authentication in C#.
You will need to install the Google.Apis.Auth Nuget package to your project. There are then multiple difference methods to do this depending on how you are storing your JSON Key, but for my example we are injecting the JSON straight into the method, which we need the GoogleCredential. The method we need to call is:
GoogleCredential.FromJson(gcpAuthenticationJson);
With gcpAuthenticationJson being the JSON string from the downloaded file. We also need to add scope to the request of access, which we can string together like below with these scopes required:
GoogleCredential.FromJson(gcpAuthenticationJson)
.CreateScoped(new List<string>
{
"https://www.googleapis.com/auth/admin.directory.user",
"https://www.googleapis.com/auth/admin.directory.group",
"https://www.googleapis.com/auth/admin.directory.user.security"
});
Now although we have given the Service Account all the permissions it requires to do the job, it needs to be executed by a GSuite Admin. We of course cannot have the admin logging in every time, therefore we just need the code to act as the admin. We can do this by adding an addition command to the methods:
GoogleCredential.FromJson(gcpAuthenticationJson)
.CreateScoped(new List<string>
{
"https://www.googleapis.com/auth/admin.directory.user",
"https://www.googleapis.com/auth/admin.directory.group",
"https://www.googleapis.com/auth/admin.directory.user.security"
}).CreateWithUser(adminEmail);
We can of course make this a little more flexable as it can be reused for other authentications, so this is the method I would recommend:
///<summary>
///GettheGCPCredentialviatheServiceAccount
///https://cloud.google.com/docs/authentication/production
///</summary>
///<paramname="authJson">DownloadedAuthenticationJSON</param>
///<paramname="apiScopes">CustomAPIScopes</param>
///<paramname="adminEmail">UserEmailAddresstoImpersonate</param>
///<returns>GCPCredentials</returns>
publicGoogleCredential GetGcpCredential(string authJson,List<string> apiScopes=null,string adminEmail="")
{
var googleCredential = GoogleCredential.FromJson(authJson)
.CreateScoped(apiScopes ?? new List<string>
{
"https://www.googleapis.com/auth/cloud-platform"
});
if(!string.IsNullOrEmpty(adminEmail))
googleCredential=googleCredential.CreateWithUser(adminEmail);
return googleCredential;
}
From this can then create users with the SDK using this simple bit of code:
var directoryService = new DirectoryService( new BaseClientService.Initializer
{
HttpClientInitializer = GetGcpCredential(authJson, apiScopes, userEmail)
});
try
{
var request = directoryService.Users.Insert(userData);
return await request.ExecuteAsync();
}
finally
{
directoryService.Dispose();
}
