DEV Community


GCP Api Gateway: Firebase Authentication

amammay profile image Alex Mammay Updated on ・5 min read

Google Cloud Platform Api Gateway

github repo --> here

What is API Gateway?

As per the documentation, Api gateway is a fully managed gateway for serverless workloads.

So really at the end of the day, that boils down to a serverless gateway for you serverless api's... Man that's alot of serverless.

What does API Gateway do?

API gateway will act as the middleman between an end user and your services. You describe your services according to the OpenAPI specification,
upload the specification to api gateway center and then finally deploy the spec to a gateway. API Gateway also provides a suite of utilities, such as monitoring, logging and authentication.

When should I use API Gateway?

If you are going to be using the serverless GCP eco-system(Cloud Functions, Cloud Run, App Engine), then API Gateway will be complimentary to those serverless products.

Why should I use API Gateway?

The most important question to answer is "why", why should I use API Gateway?

Security - Your core application can be deployed and protected by GCP IAM, that way the only direct interactions with your services will be done with the api gateway.

Externalized Configuration - You have an external way to manage application authentication, service url mapping, and API documentation that lives outside the context of the application.

Less Code - Your application itself won't have to worry about validating JWT/Api Keys since those will be handled at the gateway layer, and the result will be forwarded to your application. The less code you write, the fewer bugs there will be 😬

Observability - All your performance metrics will roll up to a single, easy to view dashboard with all your KPI's such as request latency, error rates, requests per second and more.

Securing Cloud Run Services with Firebase Authentication.

First we will take a look at our openapi specification file to get an understanding of our api. It is pretty straight forward, a single endpoint named /greet that will echo back the users name but in a "greeted" format.


swagger: '2.0'
  # Title of the api gateway
  title: gateway
  description: Sample API on API Gateway with a Cloud Run backend
  version: 1.0.0
  - https
  - application/json
# The cloud run service url, this could also be defined per path as well in case you have multiple cloud run services that
# make up a single gateway
  address: "YOUR-CLOUD_RUN-URL"
    authorizationUrl: ""
    flow: "implicit"
    type: "oauth2"
    # Replace YOUR-PROJECT-ID with your project ID
    x-google-issuer: ""
    x-google-jwks_uri: ""
    x-google-audiences: "YOUR-PROJECT-ID"
      summary: Greets the user
      operationId: greet
      # define that our service uses the firebase security definition
        - firebase: [ ]
          description: A successful response
            type: object
            # our object look like `{name: ""}`
                type: string
                description: The users name

Now we will take a peek at the code that will fulfill the contract of the api.


func (s *server) routes() {
    s.router.HandleFunc("/greet", s.handleAuth(s.handleGreeting()))

//handleGreeting will fetch the UserInfo struct that is stored in context from our auth middleware and use that to greet the person that called our api
func (s *server) handleGreeting() http.HandlerFunc {

    type person struct {
        Name string `json:"name"`

    return func(writer http.ResponseWriter, request *http.Request) {

        writer.Header().Set("Content-Type", "application/json")

        // fetch the token user object that is stored in context
        userObj := request.Context().Value(gatewayUserContext).(UserInfo)

        // greet the user 👋
        p := person{Name: fmt.Sprintf("Hello 👋 %s", userObj.Name)}
        decoder := json.NewEncoder(writer)

        if err := decoder.Encode(p); err != nil {
            http.Error(writer, err.Error(), http.StatusInternalServerError)

And just for a quick review of the Auth Middleware.


const gatewayUserInfoHeader = "X-Apigateway-Api-Userinfo"
const gatewayUserContext = "GATEWAY_USER"

type UserInfo struct {
    Name          string   `json:"name"`
    Picture       string   `json:"picture"`
    Iss           string   `json:"iss"`
    Aud           string   `json:"aud"`
    AuthTime      int      `json:"auth_time"`
    UserID        string   `json:"user_id"`
    Sub           string   `json:"sub"`
    Iat           int      `json:"iat"`
    Exp           int      `json:"exp"`
    Email         string   `json:"email"`
    EmailVerified bool     `json:"email_verified"`
    Firebase      Firebase `json:"firebase"`
type Identities struct {
    GoogleCom []string `json:""`
    Email     []string `json:"email"`
type Firebase struct {
    Identities     Identities `json:"identities"`
    SignInProvider string     `json:"sign_in_provider"`

// handleAuth is a piece of middleware that will parse the gatewayUserInfoHeader from the request and add the UserInfo to the request context
func (s *server) handleAuth(h http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {

        encodedUser := r.Header.Get(gatewayUserInfoHeader)
        if encodedUser == "" {
            http.Error(w, "User Not Available", http.StatusForbidden)
        decodedBytes, err := base64.RawURLEncoding.DecodeString(encodedUser)
        if err != nil {
            http.Error(w, "Invalid UserInfo", http.StatusForbidden)
        decoder := json.NewDecoder(bytes.NewReader(decodedBytes))
        var userToken UserInfo
        err = decoder.Decode(&userToken)
        if err != nil {
            http.Error(w, "Invalid UserInfo", http.StatusForbidden)

        ctx := context.WithValue(r.Context(), gatewayUserContext, userToken)
        h.ServeHTTP(w, r.WithContext(ctx))


You can see the rest of the code for the application in the github repo.

Enable API's and Create service account

Make sure you enable the following api's on your project

gcloud services enable
gcloud services enable
gcloud services enable

Lets create our api gateway service account

gcloud iam service-accounts create api-gateway

gcloud projects add-iam-policy-binding YOUR_PROJECT_ID --member "" --role "roles/run.invoker"
gcloud projects add-iam-policy-binding YOUR_PROJECT_ID --member "" --role "roles/iam.serviceAccountUser"

Build and Deployment

Since we are going to be using cloud build to roll everthing out, lets get our container built and deployed with gcloud builds submit



  # Run the docker build
  - name: ''
    args: [ 'build', '-t', '$PROJECT_ID/greeter', '.' ]

  # push the docker image to the private GCR registry
  - name: ''
    args: [ 'push', '$PROJECT_ID/greeter' ]

  # deploy to cloud run
  - name: ''
    entrypoint: gcloud
    args: [ 'run', 'deploy', 'greeter', '--image', '$PROJECT_ID/greeter', '--region', 'us-central1', '--platform', 'managed', '--no-allow-unauthenticated' ]

  - '$PROJECT_ID/greeter'

Now that we have the cloud service deployed, we just need to get our cloud run url gcloud run services describe greeter --format 'value(status.url)'
and to verify its secure we can try to curl the endpoint curl $(gcloud run services describe greeter --format 'value(status.url)') and we should get a 403.

The next step is to take that url from our endpoint and plug it into our api spec as the address for the x-google-backend

# The cloud run service url, this could also be defined per path as well in case you have multiple cloud run services that
# make up a single gateway
  address: "YOUR-CLOUD_RUN-URL"

Now we are turning to the home stretch, we just need to deploy our gateway/config

# create api config
gcloud beta api-gateway api-configs create echoconf \
  --api=gateway --openapi-spec=openapi2-run.yaml \

# create gateway with config
gcloud beta api-gateway gateways create gateway \
  --api=gateway --api-config=echoconf \

#get hostname from gateway
gcloud beta api-gateway gateways describe gateway \
  --location=us-central1 --format 'value(defaultHostname)'

Now if we curl the gateway endpoint with

curl "https://$(gcloud beta api-gateway gateways describe gateway --location=us-central1 --format 'value(defaultHostname)')/greet"

we will get a 401 since we didn't attach a firebase identity token to request.

But once you attach the token to the request as either a query param of access_token or as an Authorization header with bearer token

curl "https://$(gcloud beta api-gateway gateways describe gateway --location=us-central1 --format 'value(defaultHostname)')/greet?access_token=ACCESS_TOKEN"

We will get back our greeted message! {
"name": "Hello 👋 Alex Mammay"

Discussion (11)

Editor guide
rhernand3z profile image
Rafael H

Great article @amammay ,

I am trying to accomplish something similar but with an API key approach. I followed similar steps and changed the openapi yml to use API key as the security definition. Unfortunately, I keep getting 403 errors even after I created an API key with no restrictions. Would you have some tips when integrating API Gateway with API keys on Cloud Run? Appreciate your help

amammay profile image
Alex Mammay Author

Yea sure thing! ill dig into it, and write up a post about it 😀

amammay profile image
Alex Mammay Author

@rhernand3z after doing a bit of digging the main thing i could see you having problems with api key auth is to make sure you have this in your security definition

  # This section configures basic authentication with an API key.
    type: "apiKey"
    name: "key"
    in: "query"
Enter fullscreen mode Exit fullscreen mode

and in addition to create the api key entry for

API_ID specifies the name of your API.
PROJECT_ID specifies the name of your Google Cloud project.

gcloud services enable

i believe you still need to run that command even if your api key is set to unrestricted to create the entry in GCP behind the scenes.

Thread Thread
rhernand3z profile image
Rafael H

Hey Alex,

I'll give this a shot, I didn't execute the last step via gcloud services enable..., might have been the culprit. Thanks for digging into this 👍

Thread Thread
rhernand3z profile image
Rafael H

Hey @amammay -- I was able to get it working properly. You were right the culprit was not executing:

gcloud services enable ...

Thanks for your help and a great article!

phillduffy profile image
Phill Duffy

There doesn't seem to be a lot of help around this online, thank you for your post.

I have a question around verifying the token, I am using NodeJS.

I am able to get the User information out of 'X-Apigateway-Api-Userinfo' - I am not sure if I need to use the Admin SDK to verify this Token, or whether I now just pull out the information, like you do, and trust the token has been verified - is that right?

amammay profile image
Alex Mammay Author

Yea, you should be able to pull the base64 encoded token straight from X-Apigateway-Api-Userinfo. Once you grab the header you should be to do base64 decode on it and it will have the correct json stucture

andrefedev profile image
Andres Osorio

I have a question, how can we change the url of the gateway api for our custom domain. And what is the difference with Google Cloud Endpoints?

amammay profile image
Alex Mammay Author
  1. So currently you cant assign a custom domain to api gateway yet, i would imagine some point in the future you could register a custom domain to it. (either via some native control or at a GCLB level to map as a Serverless NEG)
  2. The difference between this and cloud endpoints is that this is a managed service that you don't have to worry about running the underlying infrastructure to.
chengchinlim profile image
Cheng Chin Lim

Hi, if the requests are unauthenticated, will they still be passed to our services (App Engine)? I am afraid of getting a huge bill due to DDOS attack. Thank you.

amammay profile image
Alex Mammay Author

The requests will not be forwarded to the target endpoint if the auth is missing (as long as you have auth strictly defined within your open api spec).