@astrojs/ node

Questi contenuti non sono ancora disponibili nella tua lingua.

This adapter allows Astro to deploy your hybrid or server rendered site to Node targets.

If you’re using Astro as a static site builder, you don’t need an adapter.

Why Astro Node.js

Node.js is a JavaScript runtime for server-side code. @astrojs/node can be used either in standalone mode or as middleware for other http servers, such as Express.

Installation

Astro includes an astro add command to automate the setup of official integrations. If you prefer, you can install integrations manually instead.

Add the Node adapter to enable SSR in your Astro project with the astro add command. This will install @astrojs/node and make the appropriate changes to your astro.config.* file in one step.

npx astro add node

pnpm astro add node

yarn astro add node

Manual Install

First, add the Node adapter to your project’s dependencies using your preferred package manager.

npm install @astrojs/node

pnpm add @astrojs/node

yarn add @astrojs/node

Then, add the adapter and your desired on-demand rendering mode to your astro.config.* file:

import { defineConfig } from 'astro/config';
import node from '@astrojs/node';

export default defineConfig({
  output: 'server',
  adapter: node({
    mode: 'standalone',
  }),
});

Configuration

@astrojs/node can be configured by passing options into the adapter function. The following options are available:

Mode

Controls whether the adapter builds to middleware or standalone mode.

middleware mode allows the built output to be used as middleware for another Node.js server, like Express.js or Fastify.

import { defineConfig } from 'astro/config';
import node from '@astrojs/node';

export default defineConfig({
  output: 'server',
  adapter: node({
    mode: 'middleware',
  }),
});

standalone mode builds to server that automatically starts with the entry module is run. This allows you to more easily deploy your build to a host without any additional code.

Middleware

Ability to pass middleware to be used only with standalone mode. Gives you the ability to use packages such as http-proxy-middleware in standalone mode.

middleware specify the filename thats going to export the one (or many combined) middleware. These middleware will be added when starting standalone server.

import { defineConfig } from 'astro/config';
import node from '@astrojs/node';

export default defineConfig({
  output: 'server',
  adapter: node({
    mode: 'standalone',
    middleware: `${import.meta.dirname}/src/node_middleware.js`,
  }),
});

const combineMiddleware = (...middlewares) => {
  return (req, res, next) => {
      let index = 0;
      const run = (err) => {
          if (err) {
              return next(err);
          }
          if (index >= middlewares.length) {
              return next();
          }
          const middleware = middlewares[index++];
          try {
              middleware(req, res, run);
          } catch (error) {
              next(error);
          }
      };

      run();
  };
};

const middleware_one = (req, res, next) => {
    if (req.url === '/middleware-one') {
        res.end('This is middleware one');
    } else {
        next();
    }
};

const middleware_two = (req, res, next) => {
    if (req.url === '/middleware-two') {
        res.end('This is middleware two');
    } else {
        next();
    }
};

export default combineMiddleware(middleware_one, middleware_two);

Usage

First, performing a build. Depending on which mode selected (see above) follow the appropriate steps below:

Middleware

The server entrypoint is built to ./dist/server/entry.mjs by default. This module exports a handler function that can be used with any framework that supports the Node request and response objects.

For example, with Express:

import express from 'express';
import { handler as ssrHandler } from './dist/server/entry.mjs';

const app = express();
// Change this based on your astro.config.mjs, `base` option.
// They should match. The default value is "/".
const base = '/';
app.use(base, express.static('dist/client/'));
app.use(ssrHandler);

app.listen(8080);

Or, with Fastify (>4):

import Fastify from 'fastify';
import fastifyMiddie from '@fastify/middie';
import fastifyStatic from '@fastify/static';
import { fileURLToPath } from 'node:url';
import { handler as ssrHandler } from './dist/server/entry.mjs';

const app = Fastify({ logger: true });

await app
  .register(fastifyStatic, {
    root: fileURLToPath(new URL('./dist/client', import.meta.url)),
  })
  .register(fastifyMiddie);
app.use(ssrHandler);

app.listen({ port: 8080 });

Additionally, you can also pass in an object to be accessed with Astro.locals or in Astro middleware:

import express from 'express';
import { handler as ssrHandler } from './dist/server/entry.mjs';

const app = express();
app.use(express.static('dist/client/'));
app.use((req, res, next) => {
  const locals = {
    title: 'New title',
  };

  ssrHandler(req, res, next, locals);
});

app.listen(8080);

Note that middleware mode does not do file serving. You’ll need to configure your HTTP framework to do that for you. By default the client assets are written to ./dist/client/.

Standalone

In standalone mode a server starts when the server entrypoint is run. By default it is built to ./dist/server/entry.mjs. You can run it with:

node ./dist/server/entry.mjs

For standalone mode the server handles file serving in addition to the page and API routes.

Custom host and port

You can override the host and port the standalone server runs on by passing them as environment variables at runtime:

HOST=0.0.0.0 PORT=4321 node ./dist/server/entry.mjs

HTTPS

By default the standalone server uses HTTP. This works well if you have a proxy server in front of it that does HTTPS. If you need the standalone server to run HTTPS itself you need to provide your SSL key and certificate.

You can pass the path to your key and certification via the environment variables SERVER_CERT_PATH and SERVER_KEY_PATH. This is how you might pass them in bash:

SERVER_KEY_PATH=./private/key.pem SERVER_CERT_PATH=./private/cert.pem node ./dist/server/entry.mjs

Runtime environment variables

If an .env file containing environment variables is present when the build process is run, these values will be hard-coded in the output, just as when generating a static website.

During the build, the runtime variables must be absent from the .env file, and you must provide Astro with every environment variable to expect at run-time: VARIABLE_1=placeholder astro build. This signals to Astro that the actual value will be available when the built application is run. The placeholder value will be ignored by the build process, and Astro will use the value provided at run-time.

In the case of multiple run-time variables, store them in a separate file (e.g. .env.runtime) from .env. Start the build with the following command:

export $(cat .env.runtime) && astro build

Assets

In standalone mode, assets in your dist/client/ folder are served via the standalone server. You might be deploying these assets to a CDN, in which case the server will never actually be serving them. But in some cases, such as intranet sites, it’s fine to serve static assets directly from the application server.

Assets in the dist/client/_astro/ folder are the ones that Astro has built. These assets are all named with a hash and therefore can be given long cache headers. Internally the adapter adds this header for these assets:

Cache-Control: public, max-age=31536000, immutable

Crea una Issue su GitHub

Inviateci un feedback

@astrojs/ node

Why Astro Node.js

Installation

Manual Install

Configuration

Mode

Middleware

Usage

Middleware

Standalone

Custom host and port

HTTPS

Runtime environment variables

Assets

Più integrazioni

Framework UI

@astrojs/alpinejs

@astrojs/lit

@astrojs/preact

@astrojs/react

@astrojs/solid⁠-⁠js

@astrojs/svelte

@astrojs/vue

Adattatori SSR

@astrojs/cloudflare

@astrojs/netlify

@astrojs/node

@astrojs/vercel

Altre Integrazioni

@astrojs/db

@astrojs/markdoc

@astrojs/mdx

@astrojs/partytown

@astrojs/sitemap

@astrojs/tailwind