3
respostas

[Dúvida] Estou tomando erro 500 na chamada das funções em prod

Tudo funciona localmente, mas em prod não funciona, eu faço o deploy, verifico no serverless console e ta tudo ok, mas quando faço a chamada da erro 500 serverless.yml

org: ferreirasavio
app: aws-node-http-api-project
service: alura-serverless
frameworkVersion: '3'

params:
  default:
    dbName: alura-serverless
  dev:
    connectionString: mongodb://localhost:27017/${self:params.default.dbName}
  prod:

provider:
  name: aws
  runtime: nodejs14.x
  region: eu-west-1
  environment:
    MONGODB_CONNECTIONSTRING: ${param:connectionString}
    MONGODB_DB_NAME: ${param:dbName}

functions:
  sendResponse:
    handler: api/handlers.sendResponse
    events:
      - httpApi:
          path: /api/results
          method: post
          # request:
          #   schemas:
          #     application/json: ${file(./schemas/sendResponse.json)}
  getResult:
    handler: api/handlers.getResult
    events:
      - httpApi:
          path: /api/results/{id}
          method: get

plugins:
  - serverless-offline

esse aqui é meu handlers

const { MongoClient, ObjectId } = require("mongodb");

async function connectToDatabase(){
  const client = new MongoClient(process.env.MONGODB_CONNECTIONSTRING)
  const connection = await client.connect()
  return connection.db(process.env.MONGODB_DB_NAME)
}

function extractBody(event) {
  if (!event?.body) {
    return {
      statusCode: 422,
      body: JSON.stringify({ error: "Missing body" }),
    };
  }
  return JSON.parse(event.body);
}

module.exports.sendResponse = async (event) => {
  const { name, answers } = extractBody(event);
  const correctQuestions = [3, 1, 0, 2];
  const totalCorrectAnswers = answers.reduce((acc, answer, index) => {
    if (answer === correctQuestions[index]) {
      acc++;
    }
    return acc;
  }, 0);

  const result = {
    name,
    answers,
    totalCorrectAnswers,
    totalAnswers: answers.length,
  };

const client = await connectToDatabase()
const collection = await client.collection('results')
const { insertedId} = await collection.insertOne(result)
  return {
    statusCode: 201,
    body: JSON.stringify({
      resultId: insertedId,
      __hypermedia: {
        href: `/results.html`,
        query: { id: insertedId },
      },
    }),
    headers: {
      'Content-Type': 'application/json'
    }
  };
};

module.exports.getResult = async (event) => {
  const client = await connectToDatabase()
  const collection = await client.collection('results')
  const result = await collection.findOne({
    _id: new ObjectId(event.pathParameters.id)
  })

  if (!result) {
    return {
      statusCode: 404,
      body: JSON.stringify({error: 'Result not found'}),
      headers: {
        'Content-Type': 'application/json'
      }
    }
  }
  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(result)
  }
}
3 respostas

Um erro 500 geralmente indica um problema no servidor, que pode ser causado por diversos fatores. Dado que você mencionou que "tudo funciona localmente, mas em prod não funciona", a causa mais provável é uma diferença no ambiente de produção que não está presente localmente. Isso pode ser uma configuração de ambiente, uma dependência, ou algo relacionado à conexão com o banco de dados MongoDB. Aqui estão algumas coisas para verificar e testar:

1. Variáveis de Ambiente

Verifique se todas as variáveis de ambiente necessárias estão corretamente configuradas no ambiente de produção, especialmente MONGODB_CONNECTIONSTRING e MONGODB_DB_NAME.

No seu serverless.yml, você tem:

environment:
  MONGODB_CONNECTIONSTRING: ${param:connectionString}
  MONGODB_DB_NAME: ${param:dbName}

Certifique-se de que os valores para connectionString e dbName estejam definidos corretamente para o ambiente de produção (prod) em seu arquivo de parâmetros ou no console de gerenciamento da AWS.

2. Conexão com o MongoDB

  • String de Conexão: Assegure-se de que a string de conexão do MongoDB está correta e que o IP do servidor onde a função AWS Lambda é executada está na lista de IPs permitidos no MongoDB. Muitas vezes, a configuração de IPs permitidos ou a autenticação podem causar problemas de conexão.
  • Versão do MongoDB: Verifique se a versão do cliente MongoDB (mongodb no package.json) é compatível com a versão do seu cluster MongoDB.
  • Timeout: Operações que demoram para ser completadas podem levar ao erro 500 devido ao timeout. Aumente o tempo de timeout da função Lambda e veja se isso resolve o problema.

3. Logs

Verifique os logs do CloudWatch para a função Lambda que está tendo problemas. Os logs podem oferecer detalhes específicos sobre o erro, como problemas de conexão com o banco de dados, erros de sintaxe ou exceções não tratadas no código.

4. Políticas de Permissão

Certifique-se de que a função Lambda tem permissão para acessar os recursos que ela precisa, como o banco de dados MongoDB. Você pode precisar adicionar políticas de IAM à função Lambda para permitir a conexão ao MongoDB se ele estiver hospedado em um serviço que exige autenticação via IAM.

5. Depuração Local com Conexão de Produção

Como um último recurso, você pode tentar configurar sua função Lambda para usar a string de conexão de produção do MongoDB (temporariamente) em seu ambiente local para ver se consegue reproduzir o erro. Isso pode ajudar a identificar se o problema está na conexão com o banco de dados ou em outra parte da configuração de produção.

Para cada uma dessas verificações, faça as alterações uma de cada vez e teste novamente para ver se o problema foi resolvido. Isso ajuda a identificar exatamente o que estava causando o erro 500.

Insira aqui a descrição dessa imagem para ajudar na acessibilidade

Sobre os environment, eu segui os passos do curso que ensina a conectar o mongoDB com o serverless e dali eu pego as variaveis do db, como eu deveria verificar essas variáveis?

Para verificar e trabalhar com as variáveis de ambiente ao conectar o MongoDB com aplicações serverless, há algumas etapas e boas práticas que você pode seguir. Vou te guiar por um processo básico, levando em conta que você já tenha configurado essas variáveis para sua conexão com o banco de dados MongoDB:

  1. Armazenamento Seguro: Primeiramente, certifique-se de que suas variáveis de ambiente, como strings de conexão ao banco de dados, chaves API, e outros segredos, estejam armazenadas de maneira segura.

  2. Definição das Variáveis: Ao definir variáveis de ambiente na sua função serverless, você geralmente o faz através do painel de configuração da função na plataforma de cloud que está usando ou via arquivos de configuração (como serverless.yml para o framework Serverless).

  3. Acesso às Variáveis no Código: Para acessar essas variáveis no seu código, você usaria o objeto process.env em Node.js. Por exemplo, se você tem uma variável de ambiente chamada MONGODB_URI que contém sua string de conexão, você pode acessá-la com process.env.MONGODB_URI.

  4. Verificação Local: Para testar localmente, você pode definir as variáveis de ambiente no seu sistema operacional ou usar um arquivo .env com a biblioteca dotenv em projetos Node.js, que permite carregar variáveis de ambiente desse arquivo para process.env. Lembre-se de não versionar seu arquivo .env com informações sensíveis.

  5. Logging e Debugging: Se precisar verificar se as variáveis estão sendo corretamente lidas, você pode logar temporariamente essas variáveis no início do seu código. Certifique-se de remover esses logs antes de ir para produção, para evitar a exposição de informações sensíveis.

  6. Boas Práticas de Segurança: Nunca exponha suas variáveis de ambiente em repositórios públicos, logs, ou respostas HTTP. Use sempre métodos seguros e criptografados para armazenar e acessar esses dados.

  7. Verificação na Cloud: A maioria das plataformas serverless oferece logs e ferramentas de monitoramento que podem ajudá-lo a verificar se há problemas com as variáveis de ambiente ou com a execução de suas funções. Utilize essas ferramentas para diagnosticar e solucionar problemas.

Ao seguir essas etapas e práticas recomendadas, você pode gerenciar de maneira eficaz as variáveis de ambiente na sua aplicação serverless, garantindo uma conexão segura ao MongoDB e a proteção dos seus dados sensíveis.

Insira aqui a descrição dessa imagem para ajudar na acessibilidade