这是在docker容器内的node.js以及云问题上运行的通用expressjs

Question

I have built two docker images. One with nginx that serves my angular web app and another with node.js that serves a basic express app. I have tried to access the express app from my browser in two different tabs at the same time.

In one tab the angular dev server (ng serve) serves up the web page. In the other tab the docker nginx container serves up the web page.

While accessing the node.js express app at the same time from both tabs the data starts to mix and mingle and the results returned to both tabs are a mix mash of the two requests (one from each browser tab)...

I'll try and make this more simple by showing my express app code here...but to answer this question you may not even need to know what the code is at all...so maybe check the question as stated below the code first.

'use strict';

/***********************************
GOOGLE GMAIL AND OAUTH SETUP
***********************************/
const fs = require('fs');
const {google} = require('googleapis');
const gmail = google.gmail('v1');

const clientSecretJson = JSON.parse(fs.readFileSync('./client_secret.json'));
const oauth2Client = new google.auth.OAuth2(
  clientSecretJson.web.client_id,
  clientSecretJson.web.client_secret,
  'https://us-central1-labelorganizer.cloudfunctions.net/oauth2callback'
);


/***********************************
EXPRESS WITH CORS SETUP
***********************************/
const PORT = 8000;
const HOST = '0.0.0.0';
const express = require('express');
const cors = require('cors');
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');

const whiteList = [
  'http://localhost:4200',
  'http://localhost:80',
  'http://localhost',
];

const googleApi = express();

googleApi.use(
  cors({
    origin: whiteList
  }),
  cookieParser(),
  bodyParser()
);

function getPageOfThreads(pageToken, userId, labelIds) {

  return new Promise((resolve, reject) => {
    gmail.users.threads.list(
      {
        'auth': oauth2Client,
        'userId': userId,
        'labelIds': labelIds,
        'pageToken': pageToken
      },
      (error, response) => {
        if (error) {
          console.error(error);
          reject(error);
        }
        resolve(response.data);
      }
    )
  });
}

async function getPages(nextPageToken, userId, labelIds, result) {

  while (nextPageToken) {
    let pageOfThreads = await getPageOfThreads(nextPageToken, userId, labelIds);
    console.log(pageOfThreads.nextPageToken);
    pageOfThreads.threads.forEach((thread) => {
      result = result.concat(thread.id);
    })
    nextPageToken = pageOfThreads.nextPageToken;
  }
  return result;
}


googleApi.post('/threads', (req, res) => {
  console.log(req.body);
  let threadIds = [];

  oauth2Client.credentials = req.body.token;
  let getAllThreadIds = new Promise((resolve, reject) => {
    gmail.users.threads.list(
    { 'auth': oauth2Client, 'userId': 'me', 'maxResults': 500 },

      (err, response) => {
        if (err) {
          console.error(err)
          reject(err);
        }
        if (response.data.threads) {
          response.data.threads.forEach((thread) => {
            threadIds = threadIds.concat(thread.id);
          });
        }
        if (response.data.nextPageToken) {
            getPages(response.data.nextPageToken, 'me', ['INBOX'], threadIds).then(result => {
              resolve(result);
            }).catch((err) => {
              console.error(err);
              reject(err);
            });
        } else {
          resolve(threadIds);
        }
      }
    );
  });

  getAllThreadIds
    .then((result) => {
      res.send({ threadIds: result });
    })
    .catch((error) => {
      res.status(500).send({ error: 'Request failed with error: ' + error })
    });

});

googleApi.get('/', (req, res) => res.send('Hello World!'))

googleApi.listen(PORT, HOST);
console.log(`Running on http://${HOST}:${PORT}`);

The angular app makes a simple request to the express app and waits for the reply...which it properly receives...but when I try to make two requests at the exact same time data starts to get mixed together and results are given back to each browser tab from different accounts...

...and the question is... When running containers in the cloud is this kind of thing an issue? Does one need to spin up a new container for each client that wants to actively connect to the express service so that their data doesn't get mixed?

...or is this an issue I am seeing because the express app is being accessed from locally inside my machine? If two machines with two different ip address tried to access this express server at the same time would this sort of data mixing still be an issue or would each get back it's own set of results?

Is this why people use CaaS instead of IaaS solutions?

FYI: this is demo code and the data will not be actually going back to the consumer directly...plans are to have it placed into a database and then re-extracted from the database to download all of the metadata headers for each email.

-Thank you for your time

Answer 1

I can only clear up a small part of this question:

When running containers in the cloud is this kind of thing an issue?

No. Docker is not causing any of the quirky behaviour that you are describing.

Does one need to spin up a new container for each client?

A docker container generally can serve as much users as the application inside of it can. So as long as your application can handle a lot of users (and it should), you don't have to start the same application in multiple containers. That said, when you expect a very large number of customers, there exist docker tools like Docker Compose , Docker Swarm and a lot of alternatives that will enable you to scale up later. For now, you don't need to worry about this at all.

Answer 2

I think I may have found out the issue with my code...and this is actually very important if you are using the node.js googleapis client library...

It is entirely necessary to create a new oauth2Client for each request that comes in

const oauth2Client = new google.auth.OAuth2(
  clientSecretJson.web.client_id,
  clientSecretJson.web.client_secret,
  'https://us-central1-labelorganizer.cloudfunctions.net/oauth2callback'
);

Problem: When this oauth2Client is shared it is shared by each and every person that connects at the same time...So it is necessary to create a new one each and every time a user connects to my /threads endpoint so that they do not share the same memory space (ie access_token etc.) while the processing is done.

Setting the client secret etc. and creating the oauth2Client just once at the top and then simply resetting the token for each request leads to the conflicts mentioned above.

Solution: For now simply moving the creation of this oauth2Client into each and every request that comes in makes this work properly.

Each client that connects to the service NEEDS to have their own newly created oauth2Client instance or these types of conflicts will occur...

...it's kind of a no brainer but I still find it odd that there is nothing about this in the docs? and their own examples ( https://github.com/googleapis/google-api-nodejs-client ) seem to show only one instance being created for the whole of their app...but those examples are snippets so...