Manual deployment basics

Environment configuration

1. Configure the Java environment. For instructions, see Deploy a Java environment.

2. Install a build tool.

   For Java web projects, we recommend using Maven or Gradle as your build tool.

   • Go to the Maven official website to download the Maven installation package. Then, extract it and configure the environment. For more information, see the Maven configuration documentation.

   • Go to the Gradle official website to download the Gradle installation package. Then, configure and test Gradle. For instructions, see the Gradle Quick Start.

Deploy and run

This example uses the demo-template-thymeleaf module from the open-source project spring-boot-demo.

1. Clone the project by using Git:

   sudo git clone https://github.com/xkcoding/spring-boot-demo.git

2. Build the project by using Maven:

   sudo cd spring-boot-demo/demo-template-thymeleaf
   sudo mvn clean package

   The build is complete when you see the following output.

   

3. Start the project in the background by using nohup:

   sudo nohup java -jar target/demo-template-thymeleaf.jar > app.log 2>&1 &

   • nohup: Prevents the process from receiving a hang-up (HUP) signal when the terminal is closed.

   • > app.log: Redirects the standard output to the app.log file.

   • 2>&1: Redirects the standard error to the same location as the standard output, which is app.log.

   • &: Runs the process in the background.

4. View the logs:

   sudo tail -f app.log

   The service starts successfully when you see the following output in the logs.

   

5. In a web browser, open http://<your_ecs_public_ip>:8080/demo to view the project page.

Environment configuration

1. Note: This project requires Go 1.24 or later. Run the following commands to install the Go compiler.

   # The following commands use Go 1.24.0 as an example.
   
   # Download the Go installation package.
   sudo wget https://go.dev/dl/go1.24.0.linux-amd64.tar.gz
   # Extract the package.
   sudo tar -zxvf go1.24.0.linux-amd64.tar.gz -C /usr/local/
   # Configure the environment variable.
   sudo echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile && source ~/.bash_profile

2. Verify the Go version:

   go version

   The Go environment is configured when you see the following output.

   

Build and run

This example uses the open-source project go-admin, a permission management system boilerplate built with Gin, Vue, Element UI, Arco Design, and Ant Design, featuring a decoupled frontend and backend.

1. Create a development directory:

   # Create a development directory.
   mkdir goadmin && cd goadmin

2. Clone the source code for the frontend and backend.

   Important

   The two projects must be in the same directory.

   # Get the backend code.
   sudo git clone https://github.com/go-admin-team/go-admin.git
   
   # Get the frontend code.
   sudo git clone https://github.com/go-admin-team/go-admin-ui.git

Environment configuration

Install the build tools for C++ compilation:

# For Ubuntu/Debian 
sudo apt update
sudo apt install build-essential
# For CentOS/RHEL
sudo yum groupinstall "Development Tools"

Create a C++ source file

Use a text editor such as nano or vim to create a new C++ file. For example, create a simple Hello World program.

// hello.cpp
#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Compile and run

1. Compile the program:

   sudo g++ hello.cpp -o hello

   This command generates an executable file named hello.

2. Run the compiled program:

   sudo ./hello

   The program runs successfully when you see the following output.

   

3. For larger projects, consider using a build system like Makefile or CMake to manage the compilation process.

   1. Create a file named Makefile and add the following content.

      all: hello
      
      hello: hello.cpp
          g++ hello.cpp -o hello
      
      clean:
          rm -f hello

   2. Use the make command to compile and generate the executable file.

Deploy and run

This example uses the open-source project Qexo, a fast, powerful, and elegant online static blog editor.

1. Configure the Python environment. For instructions, see Deploy a Python environment.

2. Clone the Qexo source code by using Git:

   sudo git clone https://github.com/Qexo/Qexo.git

3. Install the required project dependencies:

   sudo pip3 install -r requirements.txt

4. Deploy a MySQL database. For instructions, see Deploy a MySQL database.

5. Create a new database for Qexo named qexo_ecs:

   create database qexo_ecs;

6. In the project's root directory, open the configuration file:

   sudo cp configs.example.py configs.py
   sudo vim configs.py

   Add the following configuration to the file. Replace the database IP address, username, and password with your actual information.

   import pymysql
   pymysql.install_as_MySQLdb()
   DOMAINS = ["127.0.0.1", "yoursite.com", "localhost"]
   DATABASES = {
       'default': {
               'ENGINE': 'django.db.backends.mysql',
               'NAME': 'qexo',
               'USER': 'root',
               'PASSWORD': '',
               'HOST': '127.0.0.1',
               'PORT': '3306',
               'OPTIONS': {
                   "init_command": "SET sql_mode='STRICT_TRANS_TABLES'"
               }
       }
   }
   

7. Start the service:

   sudo python3 manage.py makemigrations
   sudo python3 manage.py migrate
   sudo python3 manage.py runserver 0.0.0.0:8000 --noreload

8. Allow traffic on port 8000 in the security group of the instance. For instructions, see Add security group rules.

9. In a web browser, open <your_ecs_public_ip>:8000. The service is deployed successfully when the following page appears. Follow the on-screen instructions to configure the system.

   

Backend

1. Configure the Node.js environment. For instructions, see Deploy a Node.js environment.

2. Clone the backend source code for the project:

   sudo git clone https://github.com/zclzone/isme-nest-serve.git

3. Install dependencies:

   sudo npm i

4. Deploy a MySQL database. For instructions, see Deploy a MySQL database.

5. Create a new database named isme:

   create database isme;

6. Initialize the project's database:

    mysql -u -p isme < init.sql

7. Open the configuration file and modify the database connection information:

   sudo vim .env

8. In the configuration file, modify the service port and database-related parameters.

   # Service port
   APP_PORT=8085
   
   # DB
   DB_HOST=localhost
   DB_PORT=3306
   DB_USER=
   DB_PWD=
   DB_DATABASE=isme
   DB_SYNC=true  # Specifies whether to enable synchronization. Set to false in a production environment.
   
   # Redis
   REDIS_URL=redis://default:123456@localhost:6379
   
   # JWT
   JWT_SECRET="d0!doc15415B0*4G0`"
   
   # Specifies whether it is a preview environment.
   IS_PREVIEW=false 

9. Start the service:

   sudo npm run start:dev

   The service starts successfully when the running logs are displayed in the console.

   

Frontend

1. Clone the frontend source code for the project:

   sudo git clone -b 2.x https://github.com/zclzone/vue-naive-admin.git

2. Install the project dependencies:

   sudo cd vue-naive-admin/
   sudo npm i

3. Start the project:

   sudo npm run dev

   The project starts successfully when the access URL is displayed in the console.

   

4. In a web browser, open http://<your_ecs_public_ip>:3200. The project is deployed successfully when the following page appears.