Couldn't deploy payload cms as standalone

[PritamSarbajna]

So we want to use payload cms's api in our astro app. We are trying to deploy payload cms in gcp using nginx.

NOTE : Our astro app is running on the same vm on port 4321 with another nginx config located on /etc/nginx/sites-enabled/xyz.doman.com

** Things we have done already **

• git cloned the repo in our vm.
• pnpm install
• set up postgresql
• did pnpm dev and curl http://localhost:3000/ and its giving us the root site
• After that pnpm build
• Ran pnpm start
• Wrote nginx config on /etc/nginx/sites-enabled/cms.xyz.doman.com
• Added ssl with certbot
• Now the url is not working

Here is nginx config cms.xyz.doman.com :

server {
    server_name cms.xyz.doman.com;

    listen [::]:443 ssl; # managed by Certbot
    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/cms.xyz.doman.com/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/cms.xyz.doman.com/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }

}

server {
    if ($host = cms.xyz.doman.com) {
        return 301 https://$host$request_uri;
    } # managed by Certbot


    listen 80;
    listen [::]:80;
    server_name cms.xyz.doman.com;
    return 404; # managed by Certbot
}

Our .env file :

DATABASE_URI=postgres://USER:<PASSWORD>@127.0.0.1:5432/DB_NAME
PAYLOAD_SECRET=payload_secret
[email protected]
INITIAL_ADMIN_PASSWORD=admin_password
PAYLOAD_PUBLIC_SERVER_URL=https://cms.xyz.doman.com
PORT=3000
NODE_ENV=production

Our next.config.mjs :

import { withPayload } from '@payloadcms/next/withPayload'

/** @type {import('next').NextConfig} */
const nextConfig = {
  output: 'standalone',
  webpack: (config, { webpack }) => {
    config.plugins.push(
      new webpack.IgnorePlugin({
        resourceRegExp: /^pg-native$|^cloudflare:sockets$/,
      }),
    )
    return config
  },
}

export default withPayload(nextConfig, { devBundleServerPackages: false })

Our payload.config.ts :

// storage-adapter-import-placeholder
import { postgresAdapter } from '@payloadcms/db-postgres'
import { payloadCloudPlugin } from '@payloadcms/payload-cloud'
import { lexicalEditor } from '@payloadcms/richtext-lexical'
import path from 'path'
import { buildConfig } from 'payload'
import { fileURLToPath } from 'url'
import sharp from 'sharp'

import { Users } from './collections/Users'
import { Media } from './collections/Media'
import { X } from './collections/X'
import { Y } from './collections/Y'
import { Z } from './collections/Z'

const filename = fileURLToPath(import.meta.url)
const dirname = path.dirname(filename)

export default buildConfig({
  serverURL: 'https://cms.xyz.doman.com',
  admin: {
    user: Users.slug,
    importMap: {
      baseDir: path.resolve(dirname),
    },
    meta: {
      icons: [
        {
          rel: 'icon',
          type: 'image/png',
          url: '/assets/logo.png',
        },
        {
          rel: 'apple-touch-icon',
          type: 'image/png',
          url: '/assets/logo.png',
        },
      ],
    },
    components: {
      graphics: {
        Logo: '/components/frontend/Logo',
        Icon: '/components/frontend/Icon',
      },
    },
  },
  collections: [Users, Media, X, Y, Z],
  editor: lexicalEditor(),
  secret: process.env.PAYLOAD_SECRET || '',
  typescript: {
    outputFile: path.resolve(dirname, 'payload-types.ts'),
  },
  db: postgresAdapter({
    pool: {
      connectionString: process.env.DATABASE_URI || '',
    },
  }),
  sharp,
  plugins: [
    payloadCloudPlugin(),
    // storage-adapter-placeholder
  ],
  onInit: async (payload) => {
    // Create an admin user if no users exist
    try {
      const users = await payload.find({
        collection: 'users',
        limit: 1,
      });

      if (users.totalDocs === 0) {
        if (process.env.INITIAL_ADMIN_EMAIL && process.env.INITIAL_ADMIN_PASSWORD) {
          await payload.create({
            collection: 'users',
            data: {
              email: process.env.INITIAL_ADMIN_EMAIL,
              password: process.env.INITIAL_ADMIN_PASSWORD,
              roles: ['admin'],
            },
          });
        } else {
          console.warn('INITIAL_ADMIN_EMAIL and INITIAL_ADMIN_PASSWORD environment variables must be set to create the first admin user.');
        }

        console.log('Admin user created successfully');
      }
    } catch (error) {
      console.error('Error creating admin user:', error);
    }
  },
})