Xây dựng hoàn thiện CRUD gRPC API với Node.js và Express (Phần 2)

 




Chào mừng quay trở lại với inovationthinking. Đây là phần 2 của loạt series "Xây dựng hoàn thiện CRUD gRPC API với Node.js và Express" . Để đọc lại phần 1 các bạn truy cập vào đây để xem lại nhé.


Tạo server gRPC Node.js

Bây giờ chúng ta đã định nghĩa tất cả các trình xử lý RPC, giờ chúng ta đã sẵn sàng tạo server gRPC để lắng nghe các yêu cầu. Nhưng trước đó, hãy tạo tệp server/config/default.ts và thêm đoạn mã sau để tải các biến môi trường từ tệp .env.
yarn add dotenv
server/config/default.ts
import path from 'path';
require('dotenv').config({ path: path.join(__dirname, '../../.env') });

const customConfig: {
  port: number;
  dbUri: string;
} = {
  port: 8000,
  dbUri: process.env.DATABASE_URL as string,
};

export default customConfig;
Tiếp theo, tạo tệp server/app.ts và thêm mã sau để tải tệp Protobuf và thiết lập server gRPC Node.js.

server/app.ts
import path from 'path';
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import { ProtoGrpcType } from '../pb/services';
import {PostServiceHandlers} from "../pb/PostService"
import customConfig from './config/default';
import connectDB from './utils/prisma';
import { createPostHandler, deletePostHandler, findAllPostsHandler, findPostHandler, UpdatePostHandler } from './controllers/post.controller';

const options: protoLoader.Options = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};

const PORT = customConfig.port;
const PROTO_FILE = '../proto/services.proto';
const packageDef = protoLoader.loadSync(
  path.resolve(__dirname, PROTO_FILE),
  options
);

const proto = grpc.loadPackageDefinition(
  packageDef
) as unknown as ProtoGrpcType;

const server = new grpc.Server();

// Post Services
server.addService(proto.PostService.service, {
  CreatePost: (req, res)=> createPostHandler(req,res),
  UpdatePost: (req,res)=> UpdatePostHandler(req,res),
  DeletePost: (req,res)=> deletePostHandler(req,res),
  GetPost: (req, res)=> findPostHandler(req,res),
  GetPosts: (call)=> findAllPostsHandler(call)
  
} as PostServiceHandlers)
server.bindAsync(
  `0.0.0.0:${PORT}`,
  grpc.ServerCredentials.createInsecure(),
  (err, port) => {
    if (err) {
      console.error(err);
      return;
    }
    server.start();
    connectDB();
    console.log(`? Server listening on ${port}`);
  }
);
Có khá nhiều điều đang diễn ra ở trên, hãy chia nhỏ nó ra. Đầu tiên, chúng ta sử dụng gói @grpc/proto-loader để tải tệp Protobuf.

Tiếp theo, chúng ta đã cung cấp đối tượng định nghĩa gói được trả về cho hàm LoadPackageDefinition do thư viện @grpc/grpc-js cung cấp.

Tiếp theo, chúng ta gọi phương thức grpc.Server() để khởi tạo server gRPC mới sau khi đối tượng gRPC được trả về.

Trên server, chúng ta đã gọi phương thức addService() để liệt kê tất cả các dịch vụ RPC và gọi các trình xử lý thích hợp của chúng.

Cuối cùng, chúng ta gọi phương thức bindAsync() để kết nối server với một cổng và IP được chỉ định. Vì gRPC hoạt động trên HTTP/2 nên chúng ta phải tạo một kết nối không an toàn để gRPC hoạt động trên máy chủ cục bộ của chúng ta.

Chúng ta đã hoàn tất với máy chủ gRPC của Node.js. Cài đặt dependencies này để giúp chúng ta khởi động và hot-reload server gRPC.
yarn add -D ts-node-dev
Tiếp theo, thêm các tập lệnh sau vào tệp package.json:

package.json
{
"scripts": {
    "start:server": "ts-node-dev --respawn --transpile-only server/app.ts",
    "start:client": "ts-node-dev --respawn --transpile-only client/app.ts",
    "db:migrate": "npx prisma migrate dev --name post-entity --create-only --schema ./server/prisma/schema.prisma",
    "db:generate": " npx prisma generate --schema ./server/prisma/schema.prisma",
    "db:push": "npx prisma db push --schema ./server/prisma/schema.prisma"
  }
}
Mở terminal của bạn và  yarn start:server để khởi động server gRPC trên cổng 8000.

Bây giờ chúng ta đã thiết lập và chạy server, chúng ta cần tạo ứng dụng client gRPC hiểu giao diện Protobuf mà máy chủ phục vụ.

Tạo gRPC client với Node.js

Bây giờ hãy xây dựng ứng dụng client, bắt đầu bằng cách cài đặt các dependencies sau:
yarn add zod express && yarn add -D morgan @types/express @types/morgan
  • zod – Thư viện xác thực schema của TypeScript. 
  • express – một framework web Node.js. 
  • morgan – Thư viện này sẽ ghi lại các yêu cầu HTTP vào console.
Tạo các Valdidation schema với Zod

Tiếp theo, tạo các schema Zod sau sẽ được cung cấp cho Framework web Express để xác thực request body đến. Điều này sẽ đảm bảo rằng các trường bắt buộc được cung cấp trong request payload.

client/schema/post.schema.ts
import { z } from 'zod';

export const createPostSchema = z.object({
  body: z.object({
    title: z.string({
      required_error: 'Title is required',
    }),
    content: z.string({
      required_error: 'Content is required',
    }),
    category: z.string({
      required_error: 'Category is required',
    }),
    published: z.boolean({
      required_error: 'Published is required',
    }),
    image: z.string({
      required_error: 'Image is required',
    }),
  }),
});

const params = {
  params: z.object({
    postId: z.string(),
  }),
};

export const getPostSchema = z.object({
  ...params,
});

export const updatePostSchema = z.object({
  ...params,
  body: z
    .object({
      title: z.string(),
      content: z.string(),
      category: z.string(),
      published: z.boolean(),
      image: z.string(),
    })
    .partial(),
});

export const deletePostSchema = z.object({
  ...params,
});

export type CreatePostInput = z.TypeOf<typeof createPostSchema>['body'];
export type GetPostInput = z.TypeOf<typeof getPostSchema>['params'];
export type UpdatePostInput = z.TypeOf<typeof updatePostSchema>;
export type DeletePostInput = z.TypeOf<typeof deletePostSchema>['params'];
Tạo một Middleware để xác thực các request

Bây giờ, hãy tạo file client/middleware/validate.ts và thêm middleware Zod sau đây để chấp nhận lược đồ đã được định nghĩa làm đối số và xác thực yêu cầu trước khi trả về lỗi xác thực thích hợp cho client.

client/middleware/validate.ts
import { z } from 'zod';
import {Request, Response, NextFunction} from "express"

const validate =
  (schema: z.AnyZodObject) =>
  async (req: Request,res: Response, next: NextFunction): Promise<any> => {
    try {
      schema.parse({
        params:req.params,
        query: req.query,
        body: req.body,
      });

      next();
    } catch (err: any) {
      if (err instanceof z.ZodError) {
        return res.status(400).json({
          status: "fail",
          message: err.errors
        })
    
      }
      return res.status(500).json({
          status: "error",
          message: err.message
        })
    }
  };
export default validate;
Set up và Export các gRPC Client

Bây giờ chúng tôi đã sẵn sàng tạo ứng dụng client gRPC để xử lý giao tiếp với API gRPC của Node.js.Tạo file client/client.ts và thêm đoạn mã bên dưới:

client/client.ts
import path from 'path';
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import { ProtoGrpcType } from '../pb/services';

const options: protoLoader.Options = {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
};

const PROTO_FILE = '../proto/services.proto';
const packageDef = protoLoader.loadSync(
  path.resolve(__dirname, PROTO_FILE),
  options
);

export const proto = grpc.loadPackageDefinition(
  packageDef
) as unknown as ProtoGrpcType;
Các đoạn mã trên tương tự như file server/app.ts vì các đối tượng gRPC giống nhau xử lý các phiên bản client và server. Tất cả những gì chúng ta đã làm là export đối tượng proto gRPC để sử dụng trong các file khác.

Set up Express Server cho client

Bây giờ chúng ta đã có đối tượng proto gRPC, hãy tạo một service mới trên cùng IP và cổng mà server đang chạy.Để sử dụng service này, chúng ta cần tạo service Express và thêm tất cả các trình xử lý router CRUD.

client/app.ts
import * as grpc from '@grpc/grpc-js';
import customConfig from '../server/config/default';
import { proto } from "./client";
import express, { Request, Response } from "express"
import morgan from 'morgan';
import validate from './middleware/validate';
import { CreatePostInput, createPostSchema, DeletePostInput, GetPostInput, UpdatePostInput, updatePostSchema } from './schema/post.schema';
import { Post } from '@prisma/client';

const client = new proto.PostService(
  `0.0.0.0:${customConfig.port}`,
  grpc.credentials.createInsecure()
);
const deadline = new Date();
deadline.setSeconds(deadline.getSeconds() + 1);
client.waitForReady(deadline, (err) => {
  if (err) {
    console.error(err);
    return;
  }
  onClientReady();
});

function onClientReady() {
  console.log("? gRPC Client is ready")
}

const app = express()
app.use(express.json())
app.use(morgan('dev'))
app.post("/api/posts", validate(createPostSchema), async (req: Request<{},{},CreatePostInput>, res: Response)=>{
const {title,image,category,content,published} = req.body
  client.CreatePost(
    {
      title,
      content,
      category,
      image,
      published
    },
    (err, data) => {
      if (err) {
        return res.status(400).json({
          status: "fail",
          message: err.message
        })
      }
      return res.status(201).json({
          status: "success",
          post: data?.post
        })
    }
  );
})

app.patch("/api/posts/:postId", validate(updatePostSchema), async (req: Request<UpdatePostInput['params'],{},UpdatePostInput['body']>, res: Response)=>{
const {title,image,category,content,published} = req.body
  client.UpdatePost(
    {
      id: req.params.postId,
      title,
      content,
      category,
      image,
      published
    },
    (err, data) => {
      if (err) {
        return res.status(400).json({
          status: "fail",
          message: err.message
        })
      }
      return res.status(200).json({
          status: "success",
          post: data?.post
        })
    }
  );
})

app.get("/api/posts/:postId", async (req: Request<GetPostInput>, res: Response)=>{
  client.GetPost(
    {
      id: req.params.postId,
    },
    (err, data) => {
      if (err) {
        return res.status(400).json({
          status: "fail",
          message: err.message
        })
      }
      return res.status(200).json({
          status: "success",
          post: data?.post
        })
    }
  );
})

app.delete("/api/posts/:postId", async (req: Request<DeletePostInput>, res: Response)=>{
  client.DeletePost(
    {
      id: req.params.postId,
    },
    (err, data) => {
      if (err) {
        return res.status(400).json({
          status: "fail",
          message: err.message
        })
      }
      return res.status(204).json({
          status: "success",
          data: null
        })
    }
  );
})

app.get("/api/posts", async (req: Request, res: Response)=>{
  const limit = parseInt(req.query.limit as string) || 10
  const page = parseInt(req.query.page as string) || 1
  const posts: Post[] = []

  const stream = client.GetPosts({page, limit})
  stream.on("data", (data: Post)=> {
    posts.push(data)
  })

  stream.on("end", ()=> {
    console.log("? Communication ended")
    res.status(200).json({
          status: "success",
          results: posts.length,
          posts
          
        })
  })

  stream.on("error", (err)=> {
    res.status(500).json({
          status: "error",
          message: err.message
        })
  })
})

const port = 8080
app.listen(port, ()=>{
  console.log("? Express client started successfully on port: "+ port)
})
Trong mỗi HTTP CRUD controller, chúng ta đã gọi từng action được cung cấp bởi interface contract để thực hiện request đến server

Vì server gRPC đã chạy trên cổng 8000 nên chúng ta đã định cấu hình server Express để chạy trên cổng 8080.

Bây giờ hãy mở 2 terminal ở project của bạn, chạy lệnh yarn start:server để khởi động server gRPC và yarn start:client để khởi động client gRPC và server Express.Đảm bảo rằng PostgreSQL Docker container đang hoạt động.

Testing

1. Mở ứng dụng postman lên và chạy thử api create post

METHOD: POST
URL: localhost:8080/api/posts
BODY:
{
    "title": "My second post demo",
    "content": "My second content",
    "category": "node.js",
    "published": false,
    "image": "test.png"
}







2. Api update post theo id

METHOD: PATCH
URL: localhost:8080/api/posts/:postId
BODY:
{
  "title": "My second post demo update",
  "content": "My second content update",
  "category": "Node.js",
  "published": true,
  "image": "demo2.png"
}



3. Api get 1 bản ghi Post theo id

METHOD: GET
URL: localhost:8080/api/posts/:postId


4. Api delete 1 bản ghi post theo id

METHOD: DELETE
URL: localhost:8080/api/posts/:postId





5. Api lấy tất danh sách bản ghi Post

METHOD: GET
URL: localhost:8080/api/posts



Tổng kết

Trong bài viết này, bạn đã học cách xây dựng máy chủ và máy khách gRPC bằng TypeScript trong môi trường Node.js sử dụng cơ sở dữ liệu Postgres. Nhưng có rất nhiều thứ bạn có thể làm với gRPC.

Nhận xét

Đăng nhận xét

Bài đăng phổ biến từ blog này

Cài đặt SSL cho website sử dụng certbot

Hình ảnh
1. SSL là gì. Trước khi nói về ssl chúng ta nhắc lại về HTTP là gì đã nhé.HTTP là giao thức dùng để truyền nhận dữ liệu.Nhược điểm của http là dữ liệu được truyền dưới dạng plain text, không hề được mã hóa hay bảo mật nên nếu gói tin chúng ta gửi bằng http bị tin tặc bắt được thì mọi thông tin sẽ bị lộ. SSL viết tắt của cụm từ Secure Sockets Layer là tiêu chuẩn về an ninh công nghệ trên toàn cầu, nói dễ hiểu thì ssl thực hiện mã hóa thông tin truyền nhận, các dữ liệu được gửi qua phương thức này sẽ được mã hóa, website của bạn nếu sử dụng ssl thì sẽ có https trên url.Nhìn chung phương thức https có độ bảo mật cao hơn nhiều so với http, mặc dù không phải tuyệt đối. 2.Cài đặt SSL. A.Trước tiên chúng ta cần cài đặt nginx để làm web server Đối với ubuntu thì các bạn chạy các lệnh sau: $ sudo apt update $ sudo apt install nginx $ sudo ufw allow 'Nginx HTTP' Đối với Centos thì các bạn chạy lệnh : $ sudo yum install epel-release $ sudo yum install nginx $ sudo systemctl start nginx N
Read more »

Xây dựng một hệ thống comment real-time hoặc chat đơn giản sử dụng Pusher

Hình ảnh
Hế lô các bạn, các bạn khỏe không?Sau một thời gian nghỉ ngơi vì dịch nên mình đã quên hết code rồi :)).Sợ code không nổi nữa nên nay lên mò mò làm một app chat đơn giản cho đỡ lụt nghề.Lên mạng đọc tới đọc lui thấy khó thực sự =)).Bất ngờ đọc được một vài bài giới thiệu pusher nên mình cũng lọ mọ thử viết một cái ai ngờ nó chạy được nên tranh thủ viết lại cho cho các bạn cùng xem cho vui. 1.Pusher là gì? Pusher là một dịch vụ cloud, tạo ra một server trung gian giúp chúng ta có thể xử lý các tác vụ thời gian thực. Dữ liệu được gửi tới pusher, và pusher lại gửi nó đi tới các client đã subscribe (đăng ký) và các channel. Trong đó Pusher Channel cung cấp giao tiếp thời gian thực giữa các máy chủ, ứng dụng và thiết bị. Các kênh được sử dụng cho các biểu đồ thời gian thực, danh sách người dùng thời gian thực, bản đồ thời gian thực, chơi trò chơi nhiều người chơi và nhiều loại cập nhật giao diện người dùng khác. Nó có một thư viện hỗ trợ mọi thứ như trình duyệt web, ứng dụng iOS và Andr
Read more »

CÁC BÀI TẬP SQL CƠ BẢN - PART 1

Hình ảnh
  Thời gian gần đây mình có được nhờ giải mấy bài SQL cho các em, lâu không làm lại, thấy khá thú vị nên hôm nay lên mạng tìm mấy bài làm cho zui.Mình viết lại đây coi như note lại để lưu lại,các bạn cùng làm với mình nhé Đề 1: Giải thích qua về đề bài. Query 2 thành phố có tên ngắn nhất và dài nhất  cùng với số ký tự trong tên của 2 thành phố ấy trong bảng STATION. Đáp án : SELECT CITY, LENGTH (CITY) FROM STATION ORDER BY LENGTH (CITY) ASC , CITY LIMIT 1; SELECT CITY, LENGTH (CITY) FROM STATION ORDER BY LENGTH (CITY) DESC , CITY LIMIT 1; Đề 2: Giải thích qua về đề bài : Query danh sách tên thành phố bắt đầu bằng các nguyên âm (a, e, i, o, u) Đáp án : SELECT DISTINCT CITY FROM STATION WHERE CITY LIKE "A%" OR CITY LIKE "E%" OR CITY LIKE "I%" OR CITY LIKE "O%" OR CITY LIKE "U%" ; Đề 3:  Giải thích đề bài : Query danh sách tên thành phố kết thúc bằng các nguyên âm (a, e , i, o,u), tương tự bài trên chỉ cần đổi logi
Read more »

Xây dựng một hệ thống tracking hành vi người dùng (phần 1)

Hình ảnh
 Hiện nay trên các trang thương mại điện tử việc tracking hành vi người dùng rất là phổ biến vậy nên hôm nay mình sẽ viết một bài viết về hệ thống tracking đơn giản đã từng được sử dụng trên một website thương mại điện tử nhé.Ngôn ngữ mình sử dụng trong bài viết này là ruby(ruby on rails) 1.Sơ đồ tổng quan hệ thống  Ứng với sơ đồ tổng quan sẽ có 2 data set tương ứng như sau và 2.Triển khai project Mô tả sơ qua về cách xây dựng hệ thống(bỏ qua các giai đoạn xây dựng xác thực tài khoản và phân quyền,vì chỉ là thành phần phụ trợ). Tạo tag -> lưu tag vào database -> render thành file js với đầu vào là các tag được tạo từ  trước 2.1.Các model tương ứng Tag model class Tag include Mongoid::Document include Mongoid::Timestamps belongs_to :user field :name, type: String, default: "" field :selector, type: Hash, default: {} field :trigger, type: Hash, default: {} field :handle, type: Hash, default: {} field :author, typ
Read more »

Xây dựng một hệ thống tracking hành vi người dùng (phần 2)

Hình ảnh
Các bạn có thể xem lại phần 1 tại đây. Sau khi đã có được các tag tiến hành xây dựng các Helper để hỗ trợ việc render ra file tracking.js Helper này có nhiệm vụ xử lý các logic của file tracking.js nhưng nếu xử lý trực tiếp trên file js thì nó quá dài dòng và dễ bị lộ logic của file. JS helper module JsHelper def renderBindClicks(tags) click_tags = tags.inject([]) do |click_tags, tag| if tag&.trigger[:value] == 'click' event_type = tag&.selector[:dom] selector = if event_type == "classes element" ".#{tag&.selector[:value]}" elsif event_type == "id element" "\##{tag&.selector[:value]}" end if selector.present? click_tags << "'#{selector}'" end end click_tags end if click_tags.present? return "[#{click_tags.uniq.join(', ')}].forEach(bindClick);".html_safe end
Read more »

Enterprise architecture trên 1 tờ A4

Hình ảnh
Enterprise architecture là một chủ đề rộng và có rất nhiều quan điểm chi phối và thực thi. Trên thực tế có rất nhiều quan điểm về vấn đề này, mình xin giới thiệu qua một quan điểm khá hay ho trong hình dưới đây. Nếu khó nhìn các bạn có thể tải về máy và phóng to lên nhé !
Read more »

Web caching (P2)

Hình ảnh
Sau khi đọc Web caching (P1), chúng ta đã hiểu đường tác dụng, cơ chế của việc caching và đi chi tiết về Browser caching và CDN caching. Ở phần 2 chúng ta sẽ tìm hiểu về server caching và cách vận dụng linh hoạt caching để giải quyết các bài toàn performance. Mục lục Reverse proxy caching. Application caching. Áp dụng bài toán thực tế. Lời kết 1.Reverse proxy caching Reverse Proxy là gì? - Là một loại proxy server trung gian giữa một server và các clients gửi request. - Nó kiểm soát yêu cầu của các clients, nếu hợp lệ, sẽ luân chuyển đến các servers thích ứng. - Ưu điểm lớn nhất của việc sử dụng Reverse proxy là khả năng quản lý tập trung. Nó giúp kiểm soát mọi requests do clients gửi lên servers. Cơ chế: - Tương tự như Browser caching và CDN caching. Reverse proxy cache lại tất cả các request resources(image, css, js, ...) và trả lại client ở tầng Proxy. Ưu điểm: - Giảm lượng request lên server. - Có thể quản lý được cache. Nhược điểm:
Read more »

Bàn về async/await trong vòng lặp javascript

Hình ảnh
  Lâu nay mình đang phải làm một dự án sdk javascript nên khá đau đầu với cái bất đồng bộ trong vòng lặp của  javascript.Để tránh quên nên mình viết lên đây cho đỡ quên.Bài viết này mình chỉ viết về một số ví dụ sử dụng async/await cho dễ hiểu nhé. 1. Chuẩn bị cho ví dụ sắp tới Giả sử chúng ta có một giỏ trái cây và số lượng của từng trái cây trong giỏ const fruitBasket = { apple: 27, grape: 0, pear: 14 } Bây giờ mình muốn lấy số lượng hoa quả trong giỏ mình sẽ viết một hàm như sau  const getNumFruit = fruit => { return fruitBasket[fruit] } const numApples = getNumFruit('apple') console.log(numApples) Giờ giả sử fruitBasket được lấy từ server chứ không phải mình khai báo biến như trên nữa việc lấy dữ liệu sẽ mất một vài giây, mình sẽ giả lập công việc lấy dữ liệu từ server như sau const sleep = ms => { return new Promise(resolve => setTimeout(resolve, ms)) } const getNumFruit = (s, fruit) => { return sleep(s).then(v =&
Read more »

Web caching (P1)

Hình ảnh
Câu chuyện hư cấu 1: A: *** hiểu sao code tao chỉnh sửa rồi mà deploy lên *** thấy thay đổi gì? B: Mày đã xóa cache chưa vậy? A: Làm sao để biết có cache hay không. Mà cache làm *** gì để suốt ngày phải xóa. Mất công, mất việc. One few moments later ... A: Xóa hết cache trình duyệt rồi, sao vẫn ko thay đổi code đã chỉnh sửa mày ơi. B: Ờ, cũng *** biết, đọc bài ở dưới xem sao :)) Câu chuyện hư cấu 2: C: Sao dạo này con web của tao nó chạy chậm thế nhờ? Có cách nào ko mày? D: Thế mày đã caching cho nó chưa? C: Tao đang nói web chạy chậm mà, có khi do code lởm mà, cache ciếc gì ở đây. Mà cache là cái gì vậy? D: Thôi đọc bài ở dưới đi rồi nói chuyện tiếp :)) Ok, qua 2 câu chuyện hư cấu trên, chắc các bạn cũng mường tượng được ưu, nhược điểm của Caching rồi đúng không? Vậy trong bài viết này, mình sẽ trình bày về Caching để các bạn hiểu vì sao nó lại quyền năng mà cũng lại rắc rối như thế.Hôm nay chúng ta cùng tìm hiểu về vấn đề này nhé. Mục lục Đường đi của 1 reques
Read more »

Cài đặt môi trường để code website Rails

Hình ảnh
Để xây dựng một website bẳng rails đầu tiên chúng ta cần phải xây dựng môi trường đúng chứ.Bài này mình sẽ hướng dẫn các bạn cài đặt môi trường để làm việc nhé. 1.Hệ điều hành Để làm việc được đơn giản mình gợi ý là dùng ubuntu,nếu bạn nào dùng mac thì quá tuyệt rồi.Mình không có tiền mua mac để code nên mình cài ubuntu để làm việc nhé,bạn nào có sử dụng window mà không muốn đổi hệ điều hành thì mình gợi ý nên sử dụng wubi để cài song song ubuntu nghịch cho biết, đây là bài hướng dẫn cài wubi nhé các bạn . 2.Cài đặt ruby Rails là một framework xây dựng website của ngôn ngữ ruby nên chắc chắn chúng ta phải cài ruby để làm việc rồi.Để cài đặt ruby chúng ta làm như sau: +,Bước đầu cần cài node và các công cụ phụ trợ của node curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash - curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add - echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list s
Read more »