So what is responsible AI use? In this post I will focus on how we, as individuals, can use AI responsibly. Although I do agree corporations are responsible to the social and environmental impact of using and promoting AI, but the consequence for individual users are more immediate.

It's no different from responsible drinking, responsible gaming, and responsible substance use, the essence is, we bear the consequence of our own AI use.

AI won't assume liability, at least for now. They are still an algorithm that requires massive computing power to predict the next word (token) in a response. Regardless of the guardrail or how carefully you write your prompt, they can still hallucinate and giving you the seemingly correct but wrong answers.

AI is bad at recalling context, at least for now. They are still struggling to memorize every word you have given, although we have developed various solutions like RAG or agentic retrieval, they don't have persistent memory and often drop the details as conversation grows.

AI can make mistakes, consider checking important information, at least for now. You may notice this under the input box on ChatGPT's interface. Training data can be outdated, imperfect query terms can be used when they search the internet on your behalf. Nevertheless, they will still give you a seemingly correct answer.

How can we be responsible? First, we should understand their limitations, and we should avoid overly relying on them. For example, it's probably fine to ask AI for a recipe, if you can bear the consequences of getting overcooked dinner.

But there could be more consequences in some industries. Imagine a vibe doctor who uploads your X-ray to an AI and instantly diagnoses you with cancer. A vibe lawyer whose entire defence strategy is generated by AI without checking. A vibe accountant instructing an AI agent to file your taxes and signing off immediately...and in a broader context, this could erode trust and distort public discussion. Posts like ChatGPT told me that, or Gemini said this is incorrect should absolutely be avoided, and commenting @grok is this true? should be disdained by society, unless you are being sarcastic.

Even worse, some people fabricate facts or quote legal clauses out of nowhere just to support their claims, although this is not news, the advancement of technology certainly makes it easier. These irresponsible usage also force non-user to take on the burden of fact checking, but how can we compete with an algorithm that types faster than most humans.

Responsible AI use means the user has to assume responsibility upon using them. Just like we shouldn't drive after consuming alcohol or marijuana. We shouldn't copy and paste AI-generated answers into a textbox without fact-checking. Nor should we claim something works after followed instructions provided by an AI without knowing why. It's like "I drove fine last time after drinking, so it must be safe". When stepping into unknown realms, your judgement is already impaired—so get yourself “sober” with some fundamentals first. (oh em dash—caught you. Yeah that sentence is AI-generated, and this too).

AI generates answers, but not the answer, they have never been a silver bullet, unless we eventually create an omnipotent one and maintain a good enough relationship, but that is another story. Until then, the responsibility is with us, the end users.

点点豆豆，米粮二斗，
和尚不在，请你先走。

English

Eeny, meeny, miny, moe,
Catch a tiger by the toe;
If he hollers, let him go,
Eeny, meeny, miny, moe.

French

Un, deux, trois, quatre,
Ma petite vache a mal aux pattes.
Tire-la par la queue,
Elle ira mieux dans un jour ou deux.

Two weeks ago, I was at a communion in a Chinese church, having an interesting debate as the counterclaim about whether the goal of romantic relationships should be marriage (談戀愛應不應該以結婚為目的). The time was very limited and I didn't elaborate it well. And that is the reason why I wrote this post. This post specifically discussed love in a heterosexual relationship but there is something we could learn even in other forms of relationship.

Matrilineal human kinship

Early human kinship was matrilineal, in which the inheritance was traced through the mother's side of the family. Eventually, as society became complex and women's power was reduced due to agricultural practices, patriarchy started to form, in which men held the power and dominated all, at this time, the system of marriage emerged, and it became a way for the family to be bounded together, ensuring the child was born legitimately, in the other hand, controlling a women's reproductive rights. It solidifies the patriarchal societies and reinforces the power structure and the gender roles, women were even been seen as a form of property to be exchanged between families (which is even seen in some societies today).

What marriage carries

So, what benefits does marriage bring, and what is the meaning of marriage? Since marriage was derived from the patriarchy, it is inherently patriarchal, making it largely unproportional when speaking to the benefit of marriage between man and woman, even in the modern-day context.

Marriage is a contract, it is a legal binding between two people to form a partnership and to abide by the marriage laws and regulations. In addition, marriage is often associated with the social norms and expectations that the couples are expected to follow and might face criticism, judgement or accusations from society if they deviate. Therefore, marriage has consequences, and it largely depends on the context of law and norms in society.

Marriage is a kidnapper

Although marriage is a commitment, it is not the only one and the ultimate one. Since the reality of marriage is cruel, in today's context, marriage kidnaps love. People have to pretend they still love each other, and they cannot easily leave even if there is no love. So, how come marriage becomes the goal of a romantic relationship?

Over the decades, we have used a filter when considering marriage. We think marriage is beautiful, sacred, and romantic. However, it is romantic only when love is inside. It is not and can't be when love is not in there. Not only the motion for love is kidnapped, but the concept of love is kidnapped as well.

We all want certainties, and we are trying to use marriage to seal the uncertainties of love, even when we don't figure out whether it is the right person or not. we are too impatient to get that certainty, but marriage is not the silver bullet, it has its problems to be solved as well.

The essence of a romantic relationship

A romantic relationship, in the beginning, starts with the chemical in mind, giving the passion of wanting to connect. We cannot help to fall in love, and then we dive into love, seeking for deeper connection. However, as time went by and the influence of chemistry faded, we began to use more of our rationale. We started determining whether we truly loved the person or not.

When a relationship starts, it doesn't need a reason, nor does it need an ultimate goal. Relationships are pure exploring, a voyage, a connection between souls. It contains happiness, and bitterness and is unexpected. Relationships don't need assumptions, it simply is the willingness of wanting to spend time with others and wish all the best to happen to others. Relationships are all about whether it feels right.

Now, talking about the consequence of having marriage as the ultimate goal of a romantic relationship, we gave a prophecy, and even if it is achieved, it is self-proven. We are strangled by this prophecy. We compromise, we hide, not able to display our personalities. We try to avoid conflicts, but eventually, it will re-emerge. We planted a timed bomb, and more time was "wasted" when trying to find the right person.

Set love free and let love be love

Love should be free because we always want the best to happen to the one we love. And what is more valuable than freedom? Love should have the freedom to enter or quit when it is best in everyone's interest. Because every lover deserves to have the best love in the world.

Love is selfless and love sometimes is giving up, because we are all independent individuals in the middle of our life journey. Love is openness and honesty, we should address each other when love is moving apart. Love is among the highest. And it should never be kidnapped by anyone's interest.

Love is compromise, but this compromise should never involve compromising love itself. And love is colourful, love doesn't matter about gender, orientation or race. Every form of love should be affirmed, as long as it is consented between two able-to-make-decision individuals.

Please, let love be love!

Extensive reading: Bible verses about marriage

Wives, submit to your own husbands, as to the Lord. For the husband is the head of the wife even as Christ is the head of the church, his body, and is himself its Savior. (Ephesians 5:22–24)

It is not good that the man should be alone; I will make him a helper fit for him (Genesis 2:18).

Husbands, in the same way, be considerate as you live with your wives, and treat them with respect as the weaker partner and as heirs with you of the gracious gift of life, so that nothing will hinder your prayers (1 Peter 3:7).

In those bible verses, we got this submissive wife and protective husband stereotype, and women were degraded as a belonging, a property, limiting their autonomy and agency, as well as undermining their equality in a partnership. Reinforcing the gender roles and limiting the ability (we know those were limited by the historical background, with a very patriarchal system and most of the authors were male).

However, what cannot be denied is that many men still hold the same belief (as of the writer's experience), regardless of whether they consciously or unconsciously realize, which should be alerted.

Part 1: Create the endpoint to get user info and JWT token.

In the original discussion, it was achieved by passing a JWT token and user info as the query param to log in to the admin user. But what if we want to login using a static token generated inside the admin dashboard?

First, we need to create a new API using the following command.

yarn strapi generate

On the generated files, change src/api/teleport/routes/teleport.js

module.exports = {
  routes: [
    {
      method: 'GET',
      path: '/teleport',
      handler: 'teleport.login',
      config: {
        policies: [],
        middlewares: [],
      },
    },
  ],
};

, then add the functionality in src/api/teleport/controllers/teleport.js

'use strict';

/**
 * A set of functions called "actions" for `teleport`
 */

const ADMIN_EMAIL = 'admin@example.com'

module.exports = {
   login: async (ctx, next) => {
    const hasToken = ctx.request.query && ctx.request.query.token;
    const token = hasToken ? ctx.request.query.token : null;

    if (!hasToken) {
      ctx.status = 404;
      return;
    }

    // check token
    const apiTokenService = strapi.services['admin::api-token'];
    const accessKey = await apiTokenService.hash(token);
    const storedToken = await apiTokenService.getBy({accessKey: accessKey});

    if (!storedToken) {
      ctx.status = 404;
      return;
    }

    // Deny access if expired.
    if (storedToken.expiresAt && storedToken.expiresAt < new Date()) {
      ctx.status = 404;
      return;
    }

    // only full-access token
    if (storedToken.type != 'full-access') {
      ctx.status = 404;
      return;
    }

    // get admin user
    const user = await strapi.db.query('admin::user').findOne({
      where: {
        email: ADMIN_EMAIL
      }
    })

    // hide sensitive data
    delete user.password;
    delete user.resetPasswordToken;
    delete user.registrationToken;

    const jwtToken = strapi.plugins['users-permissions'].services.jwt.issue({
      id: user.id
    });

    const payload = JSON.stringify({
      user: user,
      jwtToken
    });

    ctx.redirect('/admin/auth/login?payload=' + payload);
    return
  }
};

In the admin dashboard, we have to set the API to public. and generate a full-access token for later use. Therefore, when we access $URL/api/teleport?token=${token}, it will redirect us to the admin login page, with the payload containing user data and token as the query param.

Part 2: Login the user with the credential previously obtained

Now we need to customize the login page logic, to check if we have payload as a parameter inside the url. However, unlike v3 version, in Strapi v4, we need to do the following works to customize:

First, we need the patch-package package as a dependency.

yarn install patch-package

Editnode_modules/@strapi/admin/admin/src/pages/AuthPage/index.js after installing the package. Add the following lines below the "Redirect the user to the login page if the endpoint does not exist or there is already an admin user or the user is already logged in" code block.

  // if url param has payload
  if (search) {
    const params = new URLSearchParams(search);
    const payload = params.get('payload');

    if (payload) { 
      const { user, jwtToken } = JSON.parse(payload)

      auth.setToken(jwtToken, false);
      auth.setUserInfo(user, false);

      return <Redirect to="/" />;
    }

    else {
      return <Redirect to="/auth/login" />;
    }
  }

A patch file will be generated inside the patches folder, and run yarn build to rebuild the admin dashboard. Open $url/api/teleport?token=${token} again and you should notice it will redirect to the admin dashboard and log in the admin user.

Part 3: Don't forget to apply the patch!

When you are going to deploy Strapi to the server, remember to run the yarn patch-package command to apply the patch before rebuilding the resources.

git remote add <new_remote> <url>

2. Create a new branch tracking that remote

git checkout -b <new_branch> --track <new_remote>/main

3. Cherry-pick the commits you want

git cherry-pick <commit_hash_old>^..<commit_hash_new>

4. Resolve any conflicts and continue

git cherry-pick --continue

All done!

Setting up

First we have this piece of code

class MagicBox {
    
    var strongObj: AnyObject?
    
    weak var weakObj: AnyObject?
    
    /// this is equivalent to unowned(safe)
    /// don't make this optional in real project
    unowned var unownedObject: AnyObject?
    
    unowned(unsafe) var unownedUnsafeObject: AnyObject?
    
    init(strongObj: AnyObject, weakObj: AnyObject, unownedObj: AnyObject, unownedUnsafeObj: AnyObject) {
        self.strongObj = strongObj
        self.weakObj = weakObj
        self.unownedObject = unownedObj
        self.unownedUnsafeObject = unownedUnsafeObj
    }
    
    func all() -> String {
        // workaround so to access these variables first
        if (self.unownedUnsafeObject == nil) {}    
        if (self.unownedObject == nil) {}
        
        return "strongObj: \(strongObj)\nweakObj: \(weakObj)\nunownedObject: \(unownedObject)\nunownedUnsafeObject: \(unownedUnsafeObject)"
    }
}

Then we create some objects and referenced them in our MagicBox

var strongObj: AnyObject? = NSObject()
var weakObj: AnyObject? = NSObject()
var unownedObj: AnyObject? = NSObject()
var unownedUnsafeObj: AnyObject? = NSObject()

var magicBox = MagicBox(strongObj: strongObj!, weakObj: weakObj!, unownedObj: unownedObj!, unownedUnsafeObj: unownedUnsafeObj!)
magicBox.all()

Here is the output:

strongObj: Optional(<NSObject: 0x600002cfcb80>)
weakObj: Optional(<NSObject: 0x600002cfcba0>)
unownedObject: Optional(<NSObject: 0x600002cfcc10>)
unownedUnsafeObject: Optional(<NSObject: 0x600002cfcc20>)

Now we try to set the value of strongObj and weakObj to nil, and here is what happened, the weakObj is vanished but the strongObj is still there.

strongObj: Optional(<NSObject: 0x600002c08cd0>)
weakObj: nil
unownedObject: Optional(<NSObject: 0x600002c08d60>)
unownedUnsafeObject: Optional(<NSObject: 0x600002c08d70>)

Next we are going to set unownedUnsafeObject to nil, and we got an error

error: Execution was interrupted, reason: EXC_BAD_ACCESS (code=1, address=0x614744894bc0).
The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation.

Finally is the unownedObject, and we got a different error

error: Execution was interrupted, reason: signal SIGABRT.
The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation.

In the tutorial, it provides an example using Eureka, Feign and Hystrix. However, it is using an older version of Spring Boot, while I'm using the latested version. After checking on the project page of Hystrix, I found out it was in maintanence mode. Moreover, it seems that Spring Cloud OpenFeign has also dropped support of Hystrix.

Therefore I decided to switch to another circuit breaker since this was a easier way.

Firstly, circuit breaker should be enabled

spring:
  cloud:
    openfeign:
      circuitbreaker:
        enabled: true

Then make sure to add these annotations to the application class

@EnableFeignClients
@EnableDiscoveryClient
@SpringBootApplication

The client class and fallback should be like this:

@FeignClient(name = "microservice-provider-user", fallback = UserFeignClientFallback.class)
public interface UserFeignClient {

    @RequestMapping("/{id}")
    User findById(@PathVariable("id") Long id);

}

@Component
class UserFeignClientFallback implements UserFeignClient {

    @Override
    public User findById(Long id) {
        User user = new User();
        user.setId(-1L);
        user.setName("user");
        return user;
    }
}

Error may poped up when using the IDE, but the code will compile, for further discussion, please see this issue. Alternative might be nested the fallback class into the interface.

@Autowired
MovieController(UserFeignClient userFeignClient) {
    this.userFeignClient = userFeignClient;
}

One column could only contain one type of data (i.e. no array, no object)

Example: consider we have a table called users, which has one column telephones with data like this (111) 222-3333, (444) 555-6666, then it violates 1nf.

The approach to making the table to be compliant with 1NF is to save the telephone numbers into two columns, telephone1 and telephone2.

2NF

Each attribute of the object should only depend on the primary key. If the uniqueness of the object depends on other attributes, then it may be good to split the class into two or more classes.

Example: we now have a table called enrollments, which has the following fields: student_id, course_id, course_name, professor. Then it violates the 2nf.

Therefore, we have to extract the course info out of the table, now we have two tables, enrollments and courses.

Dependencies in the enrollments table:
(student_id, course_id) -> course_name

course_id -> course_name

3NF

There should be no transitive dependency on the non-primary attributes. If one attribute could be decided based on other attributes, it should be extracted to a new class.

Still considering the previous example, if the table courses has a column called office, then it violates the 3nf. because the attribute office depends on the column professor, not the course.

Dependencies in the course table:

course_id -> professor -> office
course_id -> office

BCNF

3NF addressed that the non-primary key attributes cannot have a transitive dependency, while BCNF further stated that the attribute should also not be dependent on the primary key. This usually occurs if there are multiple primary keys in the table.

ISBN, NAME, AUTHOR

ISBN -> NAME
(NAME, AUTHOR) -> ISBN

(NAME, AUTHOR) -> ISBN -> NAME


(NAME, AUTHOR) -> NAME

4NF

In a many-to-many relationship, if the attributes in the pivot table are not related, then it violates the 4nf relationship and should be separated into multiple many-to-many relationships.

5NF

Based on 4NF, Even if the attributes in the pivot table are related, they should be further separated.

彷若被雷击一般，思绪被拉入了时空漩涡之中；原本坚定的信念开始被怀疑占据。脑海里开始质问自己，质问 ta 人。却唯独忘记质问自己的情绪。

相信每个人都曾经有过这样的回忆。在某一刻，突然陷入绵延的情绪之中，开始怀疑自己每一个选择的意义。而自我保护也随之被触发。我们也顺利成章的忽略了怀疑这怀疑本身。思绪进入了脑补模式，输出着那些看似合理但从未发生的所谓事实。

更糟糕的是，这思绪振振有词，自信满满。而我们面对着这些「事实」，不免也少了几分自信和判断力，久而久之，这些「事实」便成为了我们脑海中真实存在的记忆。变成我们今后思考的依据之一。而成见也从此开始加深。

正如康德所言，人永远无法对本体具有直接的认识，只能通过感知和理解来尝试认识本体。这种认识是主观的，因人而异的。但因为人类思维的共性，所以在某种程度上，人类分享着相同的认知。

而面对前述的思绪漩涡，有的人选择了沉默和自我消化，ta 们意识到，如果将这些情绪作为行事的依据，未免太过武断。而且，如果不加区分地将所有情绪都当作真实的「事实」，可能会被 ta 人视为莫名其妙，甚至可能造成无法承担的后果。

让我们看一些例子：

1. 在职场上，假设有个员工经常抱怨他的主管总是偏向其他人。他可能会将这种情况视为事实，感觉自己受到了不公平的待遇。然而，如果他决定暂停一下，反思他的情绪，他可能会发现他的抱怨更多的是源于他自己的不安全感或者对承认自身不足的恐惧。一旦他认识到这一点，他就能开始探索如何提升自己的技能，而不是陷入抱怨中。
2. 一个学生可能会抱怨他的数学老师对他的期望太高。他可能会觉得这样的期望不公平，甚至认为自己无法达到。然而，如果他能够理解他的情绪，认识到这是他对自我能力的质疑，他就有可能转换自己的思维方式。他可以尝试改变自己的学习策略，寻找新的方式来提高他的数学能力，而不是一味地抱怨。
3. 在人际关系中，假设一个朋友经常抱怨她的男朋友不够关心她。如果她能够反思自己的情绪，她可能会发现她的抱怨其实源于她对被爱的渴望，而并非她的男朋友真的不关心她。理解了这一点，她可以选择和男朋友进行开放和诚实的沟通，表达自己的需要，而不是持续抱怨。

（由 GPT4 生成）

一位朋友曾经生动的总结了这种现象：「别人都没怎么你，你先自爆了」。我们的情绪往往比外界事实产生着更为重大的影响。而这，很大程度上都源于自卑感和不安全感。我们为了合理化自己的自卑和不安全感，往往加大力度进行着脑补和推理，最后得出可以佐证自己不安全感的结论。但长此以往，我们的不安全感和自卑感也进一步加深。而当坏结果发生之时，自我佐证的预言（self-proving prophecy）也得以实现。

Strapi is an open-source headless CMS built on Node.js, designed for efficient content modelling and management. It offers a user-friendly interface, allowing developers to define and structure content types easily. With its headless architecture, Strapi separates the content management system from the presentation layer, enabling flexible API consumption. It is a customizable CMS focused on content types, making it ideal for content-driven applications and websites.

PM2 is an open-source process manager for Node.js applications that simplifies management and deployment. It offers process monitoring, automatic restarts, load balancing, and log management. With PM2, developers can easily manage their Node.js applications in production.

Setting up the project

Firstly, we have to set up both Nuxt.js and Strapi, which will be referred to as frontend and backend.

# setting up Nuxt.js

mkdir nuxt-strapi
npx nuxi init frontend
cd frontend
yarn install

# setting up Strapi
yarn create strapi-app backend

After this, we will configure PM2 to handle the management of both Nuxt.js and Strapi. This setup will provide a centralized solution for managing the environment variables as well.

ecosystem.config.js:

const env = process.argv[process.argv.indexOf('--env') + 1];
const isDev = env === 'dev';

module.exports = {
  apps: [
    // Frontend - Nuxt 3
    {
      name: 'frontend',
      cwd: './frontend', // Adjust the path to your frontend project directory
      append_env_to_name: true,
      script: 'yarn',
      args: isDev ? 'dev' : 'start',
      interpreter: 'none',
      env_dev: {
        NODE_ENV: 'development',
        HOST: '0.0.0.0',
        STRAPI_URL: 'http://127.0.0.1:1337',
        PORT: 3000, // Choose the port you want to use for your frontend
      },
      watch: false,
      max_memory_restart: '1G',
      instances: 1, // Only one instance
      hooks: {
        pre_start: {
          command: 'yarn',
          args: 'build', // Build the frontend before starting
        },
      },
    },
    // Backend - Strapi
    {
      append_env_to_name: true,
      name: 'backend',
      cwd: './backend', 
      script: 'yarn',
      args: isDev ? 'develop' : 'start',
      interpreter: 'none',
      env_dev: {
        NODE_ENV: 'development',
        HOST: '0.0.0.0',
        PORT: '1337',
        URL: 'http://127.0.0.1:1337',
        APP_KEYS: "toBeModified1,toBeModified2",
        API_TOKEN_SALT: 'tobemodified',
        ADMIN_JWT_SECRET: 'tobemodified',
        JWT_SECRET: 'tobemodified',
        DATABASE_CLIENT: 'sqlite',
        DATABASE_FILENAME: './tmp/data.db'
      },
      watch: false,
      max_memory_restart: '1G',
      instances: 1, // Only one instance
      hooks: {
        pre_start: {
          command: 'yarn',
          args: 'build', // Build the backend before starting
        },
      },
    },
  ],
};

Then, we can use the following command to start both the frontend and the backend.

pm2 start ecosystem.config.js --env dev

PM2 - Ecosystem File

Advanced process manager for production Node.js applications. Load balancer, logs facility, startup script, micro service management, at a glance.

PM2 logo

To let the Nuxt.js interact with Strapi, we can add @nuxtjs/strapi dependency.

yarn add --dev @nuxtjs/strapi

Setup · Nuxt Strapi

Learn how to setup strapi module in your Nuxt 3 application.

Loading the .env file into the PM2 configuration

Although PM2 provides a nice unified entrypoint of managing the env variables and the applications, it is currently not possible to load environment variables directly from the .env file. Therefore I wrote an npm package to resolve this problem.

pm2-dotenv

A package to load environment variables from .env files for PM2 ecosystem.config.js. Latest version: 0.3.0, last published: 2 days ago. Start using pm2-dotenv in your project by running `npm i pm2-dotenv`. There are no other projects in the npm registry using pm2-dotenv.

npm

Modify the ecosystem.config.js:

const { injectEnvs } = require('pm2-dotenv')

module.exports = {
    apps: [
        {
            name: 'frontend',
            
            // add this line
            ...injectEnvs('frontend')
        },
        {
            name: 'backend',
            ...injectEnvs('backend')
        }
    ]
}

Now you can place all the variables in a .env.production file and let pm2 loads them:

FRONTEND_NODE_ENV='production'
FRONTEND_HOST='0.0.0.0'
FRONTEND_STRAPI_URL='http://127.0.0.1:1337'
FRONTEND_PORT=3000

BACKEND_NODE_ENV='production'
BACKEND_HOST='0.0.0.0'
BACKEND_PORT='1337'
BACKEND_URL='http://127.0.0.1:1337'
BACKEND_APP_KEYS="toBeModified1toBeModified2"
BACKEND_API_TOKEN_SALT='tobemodified'
BACKEND_ADMIN_JWT_SECRET='tobemodified'
BACKEND_JWT_SECRET='tobemodified'
BACKEND_DATABASE_CLIENT='sqlite'
BACKEND_DATABASE_FILENAME='./tmp/data.db'

Note that you may change the database connection from SQLite to MySQL. However, you might have to modify the config/database.js file in the Strapi project.

const path = require('path');

module.exports = ({ env }) => {
  const client = env('DATABASE_CLIENT', 'sqlite');

  const connections = {
    mysql: {
      connection: {
        connectionString: env('DATABASE_URL'),
        host: env('DATABASE_HOST', 'localhost'),
        port: env.int('DATABASE_PORT', 3306),
        database: env('DATABASE_NAME', 'strapi'),
        user: env('DATABASE_USERNAME', 'strapi'),
        password: env('DATABASE_PASSWORD', 'strapi'),
        ssl: env.bool('DATABASE_SSL', false) && {
          key: env('DATABASE_SSL_KEY', undefined),
          cert: env('DATABASE_SSL_CERT', undefined),
          ca: env('DATABASE_SSL_CA', undefined),
          capath: env('DATABASE_SSL_CAPATH', undefined),
          cipher: env('DATABASE_SSL_CIPHER', undefined),
          rejectUnauthorized: env.bool(
            'DATABASE_SSL_REJECT_UNAUTHORIZED',
            true
          ),
        },
      },
      pool: { min: env.int('DATABASE_POOL_MIN', 2), max: env.int('DATABASE_POOL_MAX', 10) },
    },
    sqlite: {
      connection: {
        filename: path.join(
          __dirname,
          '..',
          env('DATABASE_FILENAME', './tmp/data.db')
        ),
      },
      useNullAsDefault: true,
    },
  };

  return {
    connection: {
      client,
      ...connections[client],
      acquireConnectionTimeout: env.int('DATABASE_CONNECTION_TIMEOUT', 60000),
    },
  };
};

Also, you might have to change the config/server.js:

module.exports = ({ env }) => ({
  host: env('HOST', '0.0.0.0'),
  port: env.int('PORT', 1337),
  url: env('URL', 'http://0.0.0.0:1337'),
  app: {
    keys: env.array('APP_KEYS'),
  },
  webhooks: {
    populateRelations: env.bool('WEBHOOKS_POPULATE_RELATIONS', false),
  },
});

Finally, start the processes:

pm2 start ecosystem.config.js --env production

Use Nginx for reverse proxy

When all is set, the final step is to use nginx to proxy the request. You may add the following configuration to your existing nginx config. Note that in this example we put the Strapi to the /api path.

upstream strapi {
    server localhost:1337;
}

upstream nuxt {
    server localhost:3000;
}

server {
    listen 80;

    gzip            on;
    gzip_types      text/plain application/xml text/css application/javascript;
    gzip_min_length 1000;

    # Static Root
    location / {
        expires $expires;
        proxy_redirect                      off;
        proxy_set_header Host               $host;
        proxy_set_header X-Real-IP          $remote_addr;
        proxy_set_header X-Forwarded-For    $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto  $scheme;
        proxy_read_timeout          1m;
        proxy_connect_timeout       1m;
        proxy_pass                          http://nuxt;
    }

    # Strapi API and Admin
    location /api/ {
        rewrite ^/api/?(.*)$ /$1 break;
        proxy_pass http://strapi;
        proxy_http_version 1.1;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $http_host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_pass_request_headers on;
    }
}

The common approach for publishing service

Nginx is a widely-used open-source web server frequently used as a reverse proxy server. The standard configuration for using Nginx as a reverse proxy outside of Docker typically involves defining an upstream server block that specifies the IP address and port number of the backend server and then using the proxy_pass directive to forward incoming requests to the backend server.

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

When using Docker, if Nginx and the container are connected to the same Docker network, Nginx can communicate with the container using the container's hostname. Therefore, the configuration could be rewritten to this:

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend-container:80;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Service publishing with Traefik

Traefik is a modern reverse proxy that is designed for making deploying services simple. It can use service discovery to configure the services and can work with Let's Encrypt to automatically generate certificates.

docker-compose.yml:

version: '3.9'

services:
    traefik:
        image: "traefik:v2.6"
        container_name: "traefik"
        ports:
            - "80:80"
            - "443:443"
            - "8080:8080"
        volumes:
            - "./traefik.toml:/etc/traefik/traefik.toml"
            - "./letsencrypt:/letsencrypt"
            - "/var/run/docker.sock:/var/run/docker.sock:ro"
        networks:
            outbound:
                name: outbound

traefik.toml:

[entryPoints]
  [entryPoints.web]
    address = ":80"

  [entryPoints.web.forwardedHeaders]
    insecure = true

  [entryPoints.web.http.redirections.entryPoint]
    to = "websecure"
    scheme = "https"

  [entryPoints.websecure]
    address = ":443"

[certificatesResolvers.letsencrypt.acme]
  email = "janedoe@example.com"
  storage = "/letsencrypt/acme.json"
  [certificatesResolvers.letsencrypt.acme.tlsChallenge]

[api]
  dashboard = true
  insecure = true

[providers.docker]
  exposedByDefault = false
  watch = true
  network = "outbound"

Finally, you need to create an empty letsencrypt/acme.json file. Then when we want to publish the service, we can do the following:

version: '3.9'

services:
    backend:
        image: backend
        labels:
            - traefik.enable=true
            - traefik.docker.network=outbound
            - traefik.http.routers.backend.rule=Host(`example.com`)
            - traefik.http.routers.backend.entrypoints=websecure
            - traefik.http.routers.backend.tls.certresolver=letsencrypt
        networks:
            - outbound


networks:
    outbound:
        external: true
        name: outbound