I got this error on my console when I tried to use git pull:
remote: Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.
remote: Please see https://github.blog/2020-12-15-token-authentication-requirements-for-git-operations/ for more information.
fatal: unable to access "..." : The requested URL returned error: 403
It's very weird, because I just followed the documentation and created a token two weeks ago on GitHub. The token expires on Tue, Oct 26, 2021. Why has this been removed today?
From 2021-08-13, GitHub is no longer accepting account passwords when authenticating Git operations. You need to add a PAT (Personal Access Token) instead, and you can follow the below method to add a PAT on your system.
Create Personal Access Token on GitHub
From your GitHub account, go to Settings → Developer Settings → Personal Access Token → Generate New Token (Give your password) → Fillup the form → click Generate token → Copy the generated Token, it will be something like ghp_sFhFsSHhTzMDreGRLjmks4Tzuzgthdvfsrta
Now follow the below method based on your machine:
For Windows OS ⤴
Go to Credential Manager from Control Panel → Windows Credentials → find git:https://github.com → Edit → On Password replace with with your GitHub Personal Access Token → You are Done
If you don’t find git:https://github.com → Click on Add a generic credential → Internet address will be git:https://github.com and you need to type in your username and password will be your GitHub Personal Access Token → Click Ok and you are done
For macOS ⤴
Click on the Spotlight icon (magnifying glass) on the right side of the menu bar. Type Keychain access then press the Enter key to launch the app → In Keychain Access, search for github.com → Find the internet password entry for github.com → Edit or delete the entry accordingly → You are done
For a Linux-based OS ⤴
For Linux, you need to configure the local GIT client with a username
and email address,
$ git config --global user.name "your_github_username"
$ git config --global user.email "your_github_email"
$ git config -l
Once GIT is configured, we can begin using it to access GitHub.
Example:
$ git clone https://github.com/YOUR-USERNAME/YOUR-REPOSITORY
> Cloning into `YOUR-REPOSITORY`...
Username: <type your username>
Password: <type your password or personal access token (GitHub)
Now cache the given record in your computer to remembers the token:
$ git config --global credential.helper cache
If needed, anytime you can delete the cache record by:
$ git config --global --unset credential.helper
$ git config --system --unset credential.helper
Now try to pull with -v to verify
$ git pull -v
Linux/Debian
(Clone as follows):
git clone https://<tokenhere>#github.com/<user>/<repo>.git
For PhpStorm
If you are using PhpStorm, go to menu Git → pull and select authentication via Personal Access Token. Enter your PAT it will allow you to pull/push the changes.
If you're using macOS, just simply follow these steps:
Go to this link: https://github.com/settings/tokens (Profile -> settings -> developers setting -> personal access tokens). (don't go to repository setting; it's your profile setting)
Generate a new token and copy-paste it somewhere safely.
Now search for an app in your Mac, named Keychain Access.
Search for github.com (if there are multiple GitHub logins then choose Kind: Internet password), double-click it.
Click on show password, then enter your Mac's password and hit Enter.
Password should be visible by now. Now, just paste the token you generated in step 2 and click Save changes.
And that's it. Enjoy!
If you're using Windows:
Follow steps 1 and 2 as above.
Search for an application in your Windows OS, named Credential Manager → then Windows Credentials.
Search for github.com and edit the password with the token you have generated on GitHub.
Now enjoy!
Developer's hack (shortcode):
git remote set-url origin https://<githubtoken>#github.com/<username>/<repositoryname>.git
While cloning:
git clone https://<username>:<githubtoken>#github.com/<username>/<repositoryname>.git
It will work on every OS (Mac, Windows, or Linux).
Cons: You have to remember or should need to do to each repository in your local. So I'll prefer everyone to use above mentioned steps.
NOTE:
For those who don't have this entry: it could be made. one way to do it is- to clone a project. then it will ask for your username and password. instead of password give it the token and then the entry would be made.
Use My Account → Settings → Developer settings → Personal access tokens → Generate new token.
git remote set-url origin https://<token>#github.com/<username>/<repo>
For Linux these simple steps can solve your problem
If your Git password is cached in credential.helper, then unset it:
git config --local --unset credential.helper
Or, If you have set your credentials globally, then:
git config --global --unset credential.helper
Now go to your GitHub Account settings
Click Developer Settings
Select Personal Access
Generate a token with the given permissions, e.g.,
Now git pull inside your Git repository
Provide a username and the generated token as a password
That is a straightforward solution step by step.
PS: If you are annoyed by Git asking for username/token again and again, follow these three simple steps
Run nano ~/.git-credentials. Remove the GitHub line and save it.
git config --global credential.helper store
Risky as physically the token is saved in file ~/.git-credentials
Run git pull and provide the username and password only once
It will not ask for the username and access token again and again now!
GitHub has made changes in password authentication. If you are trying to access Git by username and password then it does not allow you. So use a personal access token instead of a password to access Git everywhere.
Here are the steps to generate personal access tokens.
Click here for Token - https://github.com/settings/tokens
Step 1 - Open GitHub and log in with your credentials.
Step 2 - Click on the Setting menu.
Step 3 - From the Setting menu click on Developer Settings
Step 4 - From the Developer Settings menu, click on Personal access token
Step 5 - From the Personal access token, click on the Generate new Token button.
Step 6 - Now fill up required details like Note, Expiration, Select scopes. And then click on the Generate Token button.
Step 7 - After that, a new token has been generated. Copy that generated token and use this token to access Git with username and token.
If you are using the Windows operating system then please follow the below step.
Open Control Panel → User Accounts → Manage your credentials → Windows Credentials.
It will show all generic credentials. Find your GitHub URL and click on that. Now click on the edit button. And then add the personal access token generated from GitHub into the password field. And click on the Save button.
Now you can access Git.
If you are accessing Git in Android Studio, if asked for a password then add the GitHub personal access token instead of your password everywhere.
This message means that you're using a password instead of a personal access token to access GitHub over HTTPS, and that's no longer allowed. GitHub has disabled password authentication because it's common for people to accidentally leak their passwords, and while a personal access token can be restricted to limit the damage, a password cannot.
If you haven't explicitly entered your password at a prompt, then it's likely you have a credential manager which is saving your password and sending it without prompting you.
You can follow the directions for clearing your credential manager listed in the Git FAQ:
$ echo url=https://account#github.com | git credential reject
You should use this same URL, but replace account with your own username (e.g., in my case, it would look like echo url=https://bk2204#github.com).
Then, the next time you try to push or pull, Git will prompt you for a username and password. For the username, enter your GitHub username, and for the password, generate a new personal access token on the appropriate settings page and paste it into the password field. If you're working from the command line, you may not see any indication that the password was successfully pasted; this is normal, so just hit Enter afterwards.
That will save the personal access token in your credential manager for the next time, assuming you have one set up. If you're not sure if you have one set up, run git config credential.helper and see if it outputs anything.
If you don't have one set up, you should add one so that you don't have to memorize your token. Run one of the following commands, depending on operating system:
git config --global credential.helper manager on Windows;
git config --global credential.helper osxkeychain on macOS;
git config --global credential.helper libsecret on Linux (if available); or
git config --global credential.helper store on Linux if libsecret isn't available.
Then you can try the push or pull again until you're no longer prompted.
Simplest solution (May 2022):
Create a new token at Personal access tokens
Copy token (Windows: Ctrl + C, macOS: Cmd + C, or click copy icon)
Try to push your local repository: git push
Enter your GitHub user name
Paste the token as your password
Generate an access token in GitHub from Settings → Developer settings.
If you have cloned your repository in the past and made it as origin, then you can change the authentication so,
git remote set-url origin https://<token>#github.com/<username>/<repo>.git
If you are going to clone repository after 13 August 2021, then you can use the normal clone command and set the generated access token in the password field.
For Ubuntu, use the following steps
At https://github.com/settings/tokens, go and generate a token.
git push
username: user_github_username
password: add_generated_token instead of the password.
A one-command simple solution to solve it
If your computer has no SSH key added to the GitHub account, I add information for you to do it at the end of the answer. You should do it first.
After push failed, then do this:
git remote set-url origin git#github.com:{user_id}/{project_name}.git
And push again. Then it works.
Let me show my case in the following.
(And I will guide you on how to do your case.)
At the first, when I add, commit, and push, then I meet this issue:
And then, my current Git log is the following.
In the final, this is my way to solve the issue.
In my case,
{project_name} <-> open-idea-pool
{user_id} <-> milochen0418 is the
{branch_name} <-> master
(your branch_name maybe is main, but not master)
When I push failed, the only thing I need is this one command:
git remote set-url origin git#github.com:{user_id}/{project_name}.git
Then I push it again by:
git push -u origin {branch_name}
For the example of my case,
git remote set-url origin git#github.com:milochen0418/open-idea-pool.git
git push -u origin master
It works.
--
By the way, this is the process of creating an SSH key to GitHub account.
You can refer to these two links to do it. The information here supports Mac, Windows, and Linux.
Issue on adding SSH key to GitHub
Adding a new SSH key to your GitHub account
Furthermore, if you want to clone a new project, you can do the following command:
git clone git#github.com:{user_id}/{project_name}.git
If you're using macOS and do not find the github.com entry in the KeyChain access:
Try to do a Git action
It'll ask for the user name
Enter your GitHub user name
Generate a new key from Personal access tokens
In the password field, enter this newly generated token value
Now you can see a new entry of github.com inside KeyChain Access → login
For Mac, go and create your token. You can only see it once. Copy it and store it securely.
Open up Terminal and run: gh auth login
*gh can be installed using Homebrew
Answer the questions. Make sure you pick HTTPS when asked.
First create the token on GitHub:
Click on the profile picture and in the menu select Settings
Select Developer Settings in the left menu at the bottom
Select Personal Access tokens in the left menu (third option)
Select Generate new token and follow the next steps.
If you have not installed GitHub CLI, you would not find it in your keychain Access. Therefore you should install it first.
Install GitHub CLI for macOS
brew install gh
For Windows:
winget install gh
scoop install gh
choco install gh
On the command line, enter gh auth login, follow the prompts, and provide the following answers
? What account do you want to log into? GitHub.com
? What is your preferred protocol for Git operations? HTTPS
? Authenticate Git with your GitHub credentials? Yes
? How would you like to authenticate GitHub CLI? Paste an authentication token
Paste the token you created on GitHub and press Enter.
I was using git pull on Linux with a password before.
If that is the case, the only thing you need to do is use token in place of password.
Generate an access token by going to Personal access tokens.
Here is example of git pull
git pull
Username for 'https://github.com': gitusername
Password for 'https://yourusername#github.com': //Then enter generated token
Generating a GitHub personal access token (PAT)
Log in to your GitHub account and open Settings → Developer Settings
Personal Access Tokens.
Click on Generate New Token.
Do not forget to copy and the token after generation. It is accessible only once.
Windows
Open Control Panel → User Accounts → Credential Manager.
Now, look for git:https://github.com.
Click on Edit.
Replace the password with the GitHub Personal Access Token.
MAC
Click on Spotlight Icon and search for Keychain Access.
Inside Keychain Access, search for github.com.
Now, look for the internet password entry for github.com.
Update the entry.
Go to Settings → Developer settings → generate a new token if it does not exist.
Or copy the token if it exists.
Then set the token:
git remote set-url origin https://<token>#github.com/<username>/<repo>.git/
Mac users -- a simple solution.
Set up the personal access token in GitHub:
Settings → Developer Settings → Personal access token
Open Keychain → type "GitHub"
Change the password to the personal access token.
Try commit/pushing.
Select "Always allow" and business is as usual.
To those using Sourcetree with an existing repository you must update your repository URL like so
https://<your_token>#github.com/username/repo.git
This was taken from this answer.
You can force your machine to just use SSH instead of HTTPS:
git config --global url."git#github.com:".insteadOf "https://github.com/"
It worked!
After getting the token key as said here:
Create Personal Access Token on GitHub From your GitHub account
go to Settings => Developer Settings => Personal Access Token => Generate
New Token (Give your password) => Fillup the form => click Generate
token => Copy the generated Token (it will be something like
ghp_sFhFsSHhTzMDreGRLjmks4Tzuzgthdvfsrta)
use the following in your terminal:
git clone https://your_username:your_github_token#github.com/username/private-repo.git
In Linux, you can generate a new access token in GitHub and directly replace it in place of the password in the ~.git-credentials file.
The password section starts with : and ends with #.
A quick solution for Windows users
Open Credential Manager and just remove the already-saved credentials for Git: https://github.com.
After this step, run the command again for pull/push in the terminal. GitHub will ask to log in with your default browser automatically (make sure you are logged in with GitHub in the default browser).
After successful login, we got this message:
For more help related to this, you can also watch this video.
The best solution I have found so far:
Install GitHub CLI, brew install gh or check how to install for other OSes
Type gh auth login in your terminal
Follow through like this:
What account do you want to log into?
Choose GitHub.com
What is your preferred protocol for Git operations?
Choose HTTPS
Authenticate Git with your GitHub credentials?
Choose Yes
How would you like to authenticate GitHub CLI?
Choose Login with a web browser
(Copy the one-time code and paste in the browser)
Press 'Enter' to open github.com in your browser
I was not able to clone the project that was always giving this error. The solution I encouraged was, after having generated the token as the post was spoken in the post, I did as described below.
Using a personal access token for the cloning of a new project.
For cloning, also you just need to modify the URL as you have done in step 2.
The older way to clone a repository:
git clone repository_URL folder_name
git clone https://github.com/<user>/<repository> my_project
The new way of cloning with a personal access token:
git clone https://<token>#github.com/<user>/<repository> my_project
I share my solution.
Support for password authentication was removed on August 13, 2021. Please use a personal access token instead.
Solution
Create a GitHub personal access token (PAT) and copy it.
For macOS, add it to KeyChain Access under GitHub.
Spotlight Search → type KeyChain → select KeyChain Access → search for github.com → paste your PAT
For Windows, add the PAT to Windows credentials for your user.
Search → type Credential Manager → Add your PAT to github.com
If the repository is part of an organization, you will also need to sign in to that organization with your personal access token so that the organization will recognize it. If you're already signed in, sign out first.
git clone as usual :-)
As a security precaution, GitHub automatically removes personal access tokens that haven't been used in a year. To provide additional security, we highly recommend adding expiration to your personal access tokens.
Just follow Creating a token.
For Mac users
Generate a token and set it in the keychain.
This quick video explains it well.
For Windows Users
Just instead of the keychain, you need to set up Credential Manager with the newly generated token.
Here is a quick video for Windows
After getting the token key, you can just skip all steps and go with this:
git clone https://your_username:your_github_token#github.com/username/private-repo.git
First you need SSH Key Based Authentication
Windows Tutorial: SSH Key Authentication
Linux/Mac Tutorial: SSH Key-Based Authentication
Documentation
And then
Generate a personal token
Set your user name: git config --global user.name "userName"
Set your email address: git config --global user.email "email"
git config --global credential.helper cache
git push/git pull or something user name and password (personal-token)
You can follow this video: Using personal access tokens with Git and GitHub
If you want to clone for the first time:
git clone https://<repository_owner>:<personal_access_token>#github.com/<repository_owner>/<repo>.git
Related
I'm using Google cloud build for CI/CD for my django app, and one requirement I have is to set my GOOGLE_APPLICATION_CREDENTIALS so I can perform authenticated actions in my Docker build. For example, I need to run RUN python manage.py collectstatic --noinput which requires access to my Google cloud storage buckets.
I've generated the credentials and it works well when simply including it in my (currently private) repo as a .json file, so it gets pulled into my Docker container with the COPY . . command and setting the env variable with ENV GOOGLE_APPLICATION_CREDENTIALS=credentials.json. Ultimately, I want to grab the credential value from secret manager and create the credentials file during the build stage, so I can completely remove the credentials from the repo. I tried doing this with editing cloudbuild.yaml (referencing this doc) with various implementations of the availableSecrets config, $$SECRET syntax, and build-args in the docker build command and trying to access in Dockerfile with
ARG GOOGLE_BUILD_CREDS
RUN echo "$GOOGLE_BUILD_CREDS" >> credentials.json
ENV GOOGLE_APPLICATION_CREDENTIALS=credentials.json
with no success.
If someone could advise me how to implement this in my cloudbuild.yaml and Dockerfile if its possible, or if there's another better solution altogether, would be much appreciated.
This is the relevant part of my cloudbuild.yaml
steps:
- name: gcr.io/cloud-builders/docker
args:
- build
- '--no-cache'
- '-t'
- '$_GCR_HOSTNAME/$PROJECT_ID/$REPO_NAME/$_SERVICE_NAME:$COMMIT_SHA'
- .
- '-f'
- Dockerfile
id: Build
availableSecrets:
secretManager:
- versionName: projects/PROJECT_ID/secrets/CREDENTIALS/versions/latest
env: 'CREDENTIALS'
If your container will run on Cloud Run, it's super easy: Remove the service account key file (and roughly, in most use cases, you never ever need it).
Keep in mind that a service account key file is a secret with a private key. And if you put it in your container, you simply store it in plain text. So bad for a secret!! (with dive, you can explore your container content, and steal the secret if you have access to the container directly)
But, I'm sure you know that because you want to store the secret in a secret manager. Now a question? How do you access a secret manager? Do you need a service account key file to be authenticated to access it?
In fact not.
The solution is to use ADC (Application default credentials). With the client libraries, use the get default credential method to let the library determine automatically the platform and the credential to use
On Cloud Run (as any other Google Cloud services), you have a metadata server that allows client libraries to get credentials information from the runtime service account.
On your local environment, you have 2 options:
Use your own credential. For that run the command gcloud auth application-default login. It's your own credential and permissions, not exactly the same as the Cloud Run runtime environment
Impersonate the Cloud Run runtime service account and act as itself to run your container/code locally. For that run the command gcloud auth application-default login --impersonate-service-account=<service account email>, Be sure to have the role service account token creator on the service account.
And then, run your app locally, and let the ADC use the credentials
I think I've worked out a fix. To solve the error I mentioned in my reply to #guillaume-blaquiere, I updated my build args in cloudbuild.yaml to include --network=cloudbuild, allowing me access to the correct service account credentials (credit to this answer).
The next issue I faced is with the django-storages library, returning this exception
AttributeError: you need a private key to sign credentials.the credentials you are currently using <class 'google.auth.compute_engine.credentials.Credentials'> just contains a token. see https://googleapis.dev/python/google-api-core/latest/auth.html#setting-up-a-service-account for more details.
I then came across this suggestion to add the setting GS_QUERYSTRING_AUTH = False to my django config and this seems to do the trick. My only conern is the documentation here does not go into too much detail on impacts or risks of disabling this (the bucket is public-read as it recommends). It seems to be working as intended however. So I will go with this configuration unless a better solution is put forward.
I have created a simple Google Cloud VM and enabled OS Login for it. Login using SSH keys works perfectly fine.
I would now like to allow individual users to sign in with a fixed password as well (instead of the public key).
Unfortunately, this results in an error:
$ sudo passwd myusername
passwd: Authentication token manipulation error
passwd: password unchanged
or
$ passwd
passwd: Authentication token manipulation error
passwd: password unchanged
Is it impossible to set passwords for users managed by OS Login?
By default, password-based logins are disabled for Google Cloud VMs.
Log in to the instance.
Edit the file /etc/ssh/sshd_config.
Look for the line PasswordAuthentication no.
Change it to yes.
Restart the SSH server: sudo systemctl restart sshd.
There are other password related settings. Review the documentation:
I had the same issue and found a very simple solution in Goggle's Documentation.
The user account created by Compute Engine doesn't have a password.
However, several desktop environments require one for unlocking
screensavers and authorizing administrative actions. It is therefore
important to set a password for your user:
Connect to the instance using SSH, as you did when you first set up the instance.
Create a password for the user:
sudo passwd $(whoami)
I have integrated aws amplify into and android app by following https://docs.amplify.aws/lib/q/platform/android in my mac book pro.
Now I check-out the same project into another machine mac mini. and trying to run.
I am getting this error, not sure how to fix it.
AmplifyException {message=Failure performing sync query to AppSync: [GraphQLResponse.Error{message='You are not authorized to make this call.'
tried, amplify pull, amplify configure, amplify init. but none are able to resolve this issue.
thanks in advance
Initially, you will see your graphql in Network tab failed because of Authorization.
"My case is App Sync API key is expried. – Freddie Jun 26"
This is the answer, go to Appsync / Settings / API keys.
You will see the "red" key. That means it has expired.
You just need to create a new key. Then replace this new key for appsync api inside your aws-exports.js under name aws_appsync_apiKey
If you have resolved this, I'll just leave it here so someone else can see it.
Ah! Great news, you can simply edit the date (no need to make a new one).
It's just that the default is one week.
Go to your ordinary, full, normal AWS console. GO to "aws appsync".
Then ..
If your token expired (here I'm talking about a token that was living its max 365 days and has expired) and you by any chance are publishing your application to AWS using amplify, you will need to add new token to application (simply changing it in awsexports would not be enough). To do it you must:
Find the file amplify/backend/<your_app_name>/parameters.json and there add two lines (this might be just CreateAPIKey but I've tested just one method found in this github issue and it worked).
"APIKeyExpirationEpoch": -1,
"CreateAPIKey": -1
Run amplify push. This should delete the old token. But you will be better off checking it yourself in Appsync/settings/api keys. If you have no tokens there, then you are good to go.
Go back to parameters.json file and remove our parameters (APIKeyExpirationEpoch and CreateAPIKey).
Run amplify update api. Choose your api (mine was Graphql). Choose update auth settings. Choose your default authorization method (mine Api key). Enter description for your api key and add the ttl for your api key (default is 7 so I suggest changing this one). Don't configure additional auth types.
You should get success message at the end. Now do amplify push. After a while the command should return success message and you are good to go. To double check you can verify token in your appsync. There should be one token only. Alson you can check the api calls for x-api-key value in header which should hold your new token.
I'm following this tutorial https://serverless-stack.com/chapters/test-the-apis.html to create a react js app with AWS.
I followed every steps but now I'm facing a challenge, when i want to test my api with npx command with a user I created in the user pool, it needs to change his password.
npx aws-api-gateway-cli-test --username='mail#example.com' --password='password' --user-pool-id='user-pool-id' --app-client-id='app-client-id' --cognito-region='region' --identity-pool-id='identity-pool' --invoke-url='url' --api-gateway-region='region' --path-template='/notes' --method='POST' --body='{"content":"hello world","attachment":"hello.jpg"}'
npx: installed 106 in 7.229s
Authenticating with User Pool
Given user needs to set a new password
All ids are hidden in the command.
How can I do that ? I tried the change password command but it needs an access token and I don't know where to found it.
Thanks for your help
I set data proc using the steps in link here
https://cloud.google.com/dataproc/docs/tutorials/jupyter-notebook
But my jyputer keep asking for password
I didn't set any password.
I tried my google account password that doesn't work
I ran ../root$ sudo grep -ir password
and get following, so that confirmed no password is set
.jupyter/jupyter_notebook_config.py:## Hashed password to use for web authentication.
.jupyter/jupyter_notebook_config.py:# The string should be of the form type:salt:hashed-password.
.jupyter/jupyter_notebook_config.py:#c.NotebookApp.password = u''
.jupyter/jupyter_notebook_config.py:# Only used when no password is enabled.
.local/share/jupyter/runtime/nbserver-3668.json: "password": false,
Since the initialization action just installs from latest using conda install jupyter, this appears to have been caused by a recent upstream change, specifically upgrading the notebook component from 4.2.3 to 4.3.0 causing token-based auth to be turned on by default. A recent cluster I deployed a couple weeks ago using the out-of-the-box init action didn't have the same login you're seeing; the design of the init action is to let Google Compute Engine firewalls be your layer of defense and the SSH tunnel being your secure connection, rather than relying on various third-party implementations of auth from the different Hadoop/Spark tools and web UIs.
The solution will be to add a line to setup-jupyter-kernel.sh:
echo "c.NotebookApp.token = u''" >> ~/.jupyter/jupyter_notebook_config.py
to disable jupyter-side authentication altogether and revert to the behavior a couple weeks ago. Note that if you want to do this yourself you'll have to fiddle with the INIT_ACTIONS_REPO and INIT_ACTIONS_BRANCH settings in jupyter.sh which may take some getting used to if you haven't been customizing it already. We'll try to push a fix as soon as possible and once that's done you should be able to use the out-of-the-box init action without causing the login screen again.
If you already have a cluster running, you can disable the auth for your jupyter server by running that manually as root after SSH'ing into the master:
sudo su
killall -9 jupyter-notebook
echo "c.NotebookApp.token = u''" >> ~/.jupyter/jupyter_notebook_config.py
/dataproc-initialization-actions/jupyter/internal/launch-jupyter-kernel.sh
Alternatively, if you do want to keep the new default token-authorization approach, the jupyter server actually logs a generated token to /var/log/jupyter_notebook.log; look for a line stating The Jupyter Notebook is running at: http://[all ip addresses on your system]:8123/?token=[some-token-string-here]; that token string can be plugged in to the password field or in the URL parameter as it shows.
EDIT: The fix has now been committed into Dataproc's init action repository and synced to gs://dataproc-initialization-actions. Deployments out-of-the-box once again work without an extra login page in the Jupyter UI.
A new metadata option has also been added if you do want to specify a token which Jupyter also allows to be used in the password field, with key JUPYTER_AUTH_TOKEN. Use it as follows only if you want a login page requesting your specified token (no metadata keys are necessary if you just want the old behavior of no login page):
gcloud dataproc clusters create \
--initialization-actions gs://dataproc-initialization-actions/jupyter/jupyter.sh \
--metadata JUPYTER_AUTH_TOKEN=foobarbaz
Then your login password will be foobarbaz.
When you dont set any password you can login with the your server credentials where it is installed.