Migrate from MongoDB Mongoose to Couchbase with Ottoman

Node.js 개발자와 이야기할 때 개발을 위한 데이터베이스로 NoSQL을 선택하는 것이 일반적입니다. JSON은 결국 JavaScript Object Notation의 약자이기 때문에 JavaScript와 JSON은 밀접한 관련이 있습니다. 이는 문서 지향 데이터베이스에서 가장 일반적인 형식이며 Node.js 개발자가 사용하는 경향이 있습니다.

매우 인기 있는 개발 기술 스택은 MongoDB, Express Framework, Angular 및 Node.js(MEAN) 스택이지만, 이와 유사하게 Couchbase, Express Framework, Angular 및 Node.js(CEAN) 스택도 존재합니다. 제가 나열한 모든 기술이 훌륭하지만 애플리케이션의 성능을 확장하고 유지해야 하는 경우에는 다음과 같은 기술이 더 좋을 수 있습니다. 카우치베이스 설계 방식으로 작동하기 때문입니다.

그렇다면 이미 Node.js 애플리케이션에서 MongoDB를 사용하고 있다면 어떻게 해야 할까요?

사용 중일 가능성이 높습니다. 몽구스 데이터베이스와 상호 작용하기 위한 객체 문서 모델(ODM)입니다. Couchbase에도 ODM이 있으며, 이를 오스만. 이 두 ODM 기술의 가장 큰 장점은 거의 동일한 API 세트를 공유하므로 전환이 매우 쉽다는 것입니다.

MongoDB의 REST API를 활용하여 Mongoose를 사용하는 Node.js 애플리케이션에서 Ottoman이 탑재된 Couchbase로 마이그레이션하는 방법을 살펴보겠습니다.

요구 사항

이 튜토리얼은 관련된 모든 기술 때문에 조금 다를 것입니다. 단순화를 위해 모든 것을 처음부터 구축할 예정이므로 다음은 요구 사항 및 권장 사항입니다:

먼저 Mongoose를 사용하여 Node.js에서 MongoDB REST API를 빌드하는 것으로 시작하겠습니다. 그런 다음 이 애플리케이션을 Couchbase로 마이그레이션하겠습니다.

이 예제에서는 Node.js, MongoDB 또는 Couchbase Server를 구성하는 방법을 살펴보지 않겠습니다.

NoSQL 데이터 모델 이해

몽고DB와 카우치베이스는 모두 문서 데이터베이스입니다. 하나는 BSON 데이터를 저장하고 다른 하나는 JSON을 저장하지만 개발자 관점에서 보면 매우 유사합니다. 즉, 학교에서 수업을 듣는 학생들을 중심으로 몇 가지 모델을 설계해 보겠습니다. 우리가 만드는 첫 번째 모델은 실제 강좌를 위한 것으로, 단일 강좌는 다음과 같이 보일 수 있습니다:

{
    "id": "course-1",
    "type": "course",
    "name": "Computer Science 101",
    "term": "F2017",
    "students": [
        "student-1",
        "student-2"
    ]
}

{

"id": "course-1",

"type": "코스",

"이름": "컴퓨터 과학 101",

"학기": "F2017",

"학생": [

"student-1",

"student-2"

]

}

위에서는 코스에 고유 ID가 있으며 이를 코스로 정의한 것을 확인할 수 있습니다. 코스에는 등록한 학생 목록뿐만 아니라 이름 지정 정보도 있습니다.

이제 학생 문서에 대한 모델을 정의한다고 가정해 보겠습니다:

{
    "id": "student-1",
    "type": "student",
    "firstname": "Nic",
    "lastname": "Raboy",
    "courses": [
        "course-1",
        "course-25"
    ]
}

{

"id": "student-1",

"type": "학생",

"이름": "닉",

"성": "라보이",

"코스": [

"course-1",

"course-25"

]

}

위의 모델은 코스와 비슷한 형식을 가지고 있습니다. 여기서 말하는 것은 두 문서가 서로 연관되어 있지만 여전히 반구조화되어 있다는 것입니다. 즉, 각 코스는 학생을 추적하고 각 학생은 코스를 추적한다는 것입니다. 이는 데이터를 쿼리하려고 할 때 유용합니다.

NoSQL 데이터를 모델링하는 데는 무한한 가능성이 있습니다. 실제로 '코스 및 학생' 모델을 정의하는 방법은 제가 결정한 것과는 달리 100가지가 넘을 것입니다. 그것은 전적으로 사용자에게 달려 있으며, 이것이 바로 NoSQL이 제공하는 유연성입니다. 데이터 모델링에 대한 자세한 내용은 다음을 참조하세요. 여기.

데이터 모델을 염두에 두고, 각 MongoDB와 Mongoose, Couchbase와 Ottoman을 사용하여 간단한 API 엔드포인트 집합을 만들 수 있습니다.

Express 프레임워크와 MongoDB로 API 개발하기

이론상으로는 몽고DB에서 Couchbase로 마이그레이션하는 것이므로, 먼저 몽고DB 애플리케이션에서 원하는 것이 무엇인지 파악하는 것이 합리적일 것입니다.

컴퓨터 어딘가에 프로젝트의 첫 번째 부분을 나타내는 새 디렉터리를 만듭니다. 이 디렉토리 내에서 다음을 실행합니다:

npm init --y
npm install express body-parser mongodb mongoose --save

1 2	npm init --y npm 설치 express body-파서 mongodb 몽구스 --저장

위의 명령은 다음과 같은 파일을 만듭니다. package.json 를 사용하면 네 가지 프로젝트 종속성을 각각 추적할 수 있습니다. 프로젝트의 express 종속성은 Express 프레임워크와 본문 파서 종속성을 사용하면 데이터를 변경하는 데 일반적으로 사용되는 POST, PUT, DELETE 요청에 요청 본문이 존재할 수 있습니다. 그러면 mongodb 그리고 몽구스 는 데이터베이스 작업에 필요합니다.

우리가 구축하는 프로젝트는 다음과 같은 구조를 갖습니다:

app.js
routes/
    courses.js
    students.js
models/
    models.js
package.json
node_modules/

app.js

경로/

courses.js

students.js

models/

models.js

package.json

node_modules/

디렉터리와 파일이 아직 없는 경우 해당 디렉터리와 파일을 생성하세요. 그리고 app.js 파일은 애플리케이션 드라이버가 되고 경로 에는 API 엔드포인트와 모델 에는 애플리케이션에 대한 데이터베이스 정의가 포함됩니다.

몽구스 스키마 정의하기

이제 MongoDB와 통신할 몽구스 모델부터 거꾸로 작업해 보겠습니다. 프로젝트의 models/models.js 파일을 열고 다음을 포함하세요:

var Mongoose = require("mongoose");
var Schema = Mongoose.Schema;
var ObjectId = Mongoose.SchemaTypes.ObjectId;

var CourseSchema = new Mongoose.Schema({
    name: String,
    term: String,
    students: [
        {
            type: ObjectId,
            ref: StudentSchema
        }
    ]
});

var StudentSchema = new Mongoose.Schema({
    firstname: String,
    lastname: String,
    courses: [
        {
            type: ObjectId,
            ref: CourseSchema
        }
    ]
});

module.exports.CourseModel = Mongoose.model("Course", CourseSchema);
module.exports.StudentModel = Mongoose.model("Student", StudentSchema);

var 몽구스 = require("몽구스");

var 스키마 = 몽구스.스키마;

var ObjectId = 몽구스.스키마 유형.ObjectId;

var 코스 스키마 = new 몽구스.스키마({

이름: 문자열,

용어: 문자열,

학생: [

{

유형: ObjectId,

ref: 학생 스키마

}

]

});

var 학생 스키마 = new 몽구스.스키마({

이름: 문자열,

성: 문자열,

코스: [

{

유형: ObjectId,

ref: 코스 스키마

}

]

});

모듈.수출.코스 모델 = 몽구스.모델("코스", 코스 스키마);

모듈.수출.학생 모델 = 몽구스.모델("학생", 학생 스키마);

위에서는 MongoDB 문서 스키마를 생성한 다음 이 스키마로 모델을 만들고 있습니다. 스키마가 이전에 애플리케이션 외부에서 정의했던 JSON 모델과 얼마나 유사한지 주목하세요. 우리는 id 그리고 유형 ODM이 이를 처리하기 때문입니다. 각 배열에서 우리는 다른 스키마에 대한 참조를 사용합니다. 저장 시에는 문서 ID가 표시되지만 쿼리 기술을 활용하여 해당 ID를 실제 데이터로 로드할 수 있습니다.

그렇다면 이러한 모델을 어떻게 사용할 수 있을까요?

REST API 경로 만들기

이제 라우팅 정보, 즉 API 엔드포인트를 만들려고 합니다. 예를 들어 코스 정보에 대한 모든 CRUD 엔드포인트를 만들어 보겠습니다. 프로젝트의 routes/courses.js 파일에 다음을 추가합니다:

var CourseModel = require("../models/models").CourseModel;

var router = function(app) {

    app.get("/courses", function(request, response) {
        CourseModel.find({}).populate("students").then(function(result) {
            response.send(result);
        }, function(error) {
            response.status(401).send({ "success": false, "message": error});
        });
    });

    app.get("/course/:id", function(request, response) {
        CourseModel.findOne({"_id": request.params.id}).populate("students").then(function(result) {
            response.send(result);
        }, function(error) {
            response.status(401).send({ "success": false, "message": error});
        });
    });

    app.post("/courses", function(request, response) {
        var course = new CourseModel({
            "name": request.body.name
        });
        course.save(function(error, course) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(course);
        });
    });

}

module.exports = router;

var 코스 모델 = require("../모델/모델").코스 모델;

var 라우터 = 함수(앱) {

앱.get("/courses", 함수(요청, 응답) {

코스 모델.찾기({}).채우기("students").다음(함수(결과) {

응답.보내기(결과);

}, 함수(오류) {

응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

앱.get("/코스/:ID", 함수(요청, 응답) {

코스 모델.findOne({"_id": 요청.매개변수.id}).채우기("students").다음(함수(결과) {

응답.보내기(결과);

}, 함수(오류) {

응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

앱.post("/courses", 함수(요청, 응답) {

var 코스 = new 코스 모델({

"name": 요청.body.이름

});

코스.저장(함수(오류, 코스) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(코스);

});

}

모듈.수출 = 라우터;

위의 예에는 세 개의 엔드포인트가 있습니다. 사용 가능한 모든 코스를 보고, ID별로 코스를 보고, 새 코스를 생성할 수 있습니다. 각 엔드포인트는 몽구스에 의해 구동됩니다.

app.post("/courses", function(request, response) {
    var course = new CourseModel({
        "name": request.body.name
    });
    course.save(function(error, course) {
        if(error) {
            return response.status(401).send({ "success": false, "message": error});
        }
        response.send(course);
    });
});

앱.post("/courses", 함수(요청, 응답) {

var 코스 = new 코스 모델({

"name": 요청.body.이름

});

코스.저장(함수(오류, 코스) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(코스);

});

문서를 만들 때 요청 POST 데이터가 새 모델 인스턴스화에 추가됩니다. 일단 저장 가 호출되면 MongoDB에 저장됩니다. 데이터베이스에서 데이터를 읽을 때도 비슷한 일이 발생합니다.

app.get("/courses", function(request, response) {
    CourseModel.find({}).populate("students").then(function(result) {
        response.send(result);
    }, function(error) {
        response.status(401).send({ "success": false, "message": error});
    });
});

앱.get("/courses", 함수(요청, 응답) {

코스 모델.찾기({}).채우기("students").다음(함수(결과) {

응답.보내기(결과);

}, 함수(오류) {

응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

위의 경우 찾기 함수가 호출되고 매개변수가 전달됩니다. 매개 변수가 없는 경우 모든 문서는 코스 컬렉션을 사용하면 전달된 속성에 의해 데이터가 쿼리됩니다. 이 경우 채우기 함수를 사용하면 문서 참조를 로드할 수 있으므로 ID 값을 다시 반환하는 대신 실제 문서가 반환됩니다.

이제 다른 경로를 살펴보겠습니다.

두 번째 경로는 학생 데이터 생성을 담당하지만 여기에는 예외가 있습니다. 여기서는 문서 관계도 관리할 것입니다. 프로젝트의 경로/학생.js 파일을 열고 다음 소스 코드를 포함하세요:

var CourseModel = require("../models/models").CourseModel;
var StudentModel = require("../models/models").StudentModel;

var router = function(app) {

    app.get("/students", function(request, response) {
        StudentModel.find({}).populate("courses").then(function(result) {
            response.send(result);
        }, function(error) {
            response.status(401).send({ "success": false, "message": error});
        });
    });

    app.get("/student/:id", function(request, response) {
        StudentModel.findOne({"_id": request.params.id}).populate("courses").then(function(result) {
            response.send(result);
        }, function(error) {
            response.status(401).send({ "success": false, "message": error});
        });
    });

    app.post("/students", function(request, response) {
        var student = new StudentModel({
            "firstname": request.body.firstname,
            "lastname": request.body.lastname
        });
        student.save(function(error, student) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(student);
        });
    });

    app.post("/student/course", function(request, response) {
        CourseModel.findOne({"_id": request.body.course_id}).then(function(course) {
            StudentModel.findOne({"_id": request.body.student_id}).then(function(student) {
                if(course != null && student != null) {
                    if(!student.courses) {
                        student.courses = [];
                    }
                    if(!course.students) {
                        course.students = [];
                    }
                    student.courses.push(course._id);
                    course.students.push(student._id);
                    student.save();
                    course.save();
                    response.send(student);
                } else {
                    return response.status(401).send({ "success": false, "message": "The `student_id` or `course_id` was invalid"});
                }
            }, function(error) {
                return response.status(401).send({ "success": false, "message": error});
            });
        }, function(error) {
            return response.status(401).send({ "success": false, "message": error});
        });
    });

}

module.exports = router;

var 코스 모델 = require("../모델/모델").코스 모델;

var 학생 모델 = require("../모델/모델").학생 모델;

var 라우터 = 함수(앱) {

앱.get("/학생", 함수(요청, 응답) {

학생 모델.찾기({}).채우기("코스").다음(함수(결과) {

응답.보내기(결과);

}, 함수(오류) {

응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

앱.get("/학생/:ID", 함수(요청, 응답) {

학생 모델.findOne({"_id": 요청.매개변수.id}).채우기("코스").다음(함수(결과) {

응답.보내기(결과);

}, 함수(오류) {

응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

앱.post("/학생", 함수(요청, 응답) {

var 학생 = new 학생 모델({

"이름": 요청.body.이름,

"성": 요청.body.성

});

학생.저장(함수(오류, 학생) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(학생);

});

앱.post("/학생/코스", 함수(요청, 응답) {

코스 모델.findOne({"_id": 요청.body.course_id}).다음(함수(코스) {

학생 모델.findOne({"_id": 요청.body.student_id}).다음(함수(학생) {

만약(코스 != null && 학생 != null) {

만약(!학생.코스) {

학생.코스 = [];

}

만약(!코스.학생) {

코스.학생 = [];

}

학생.코스.push(코스._id);

코스.학생.push(학생._id);

학생.저장();

코스.저장();

응답.보내기(학생);

} else {

반환 응답.상태(401).보내기({ "성공": false, "메시지": "`학생 아이디` 또는 `코스 아이디`가 유효하지 않습니다."});

}

}, 함수(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

}, 함수(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

});

}

모듈.수출 = 라우터;

처음 세 개의 API 엔드포인트는 익숙하게 보일 것입니다. 새로운 엔드포인트 학생/코스 는 코스에 학생을 추가하고 학생에게 코스를 추가하는 역할을 담당합니다.

가장 먼저 요청 ID를 기반으로 코스가 검색됩니다. 다음으로, 다른 요청 ID를 기준으로 학생을 찾습니다. 두 문서가 모두 발견되면 해당 ID가 각각의 적절한 배열에 추가되고 문서가 다시 한 번 저장됩니다.

마지막 단계는 애플리케이션 드라이버를 만드는 것입니다. 그러면 데이터베이스에 연결하여 클라이언트가 사용할 애플리케이션을 제공할 수 있습니다.

MongoDB에 연결하고 애플리케이션 서비스하기

프로젝트의 app.js 파일을 열고 다음 코드를 추가합니다:

var Mongoose = require("mongoose");
var Express = require("express");
var BodyParser = require("body-parser");

var app = Express();
app.use(BodyParser.json());

Mongoose.Promise = Promise;
var studentRoutes = require("./routes/students")(app);
var courseRoutes = require("./routes/courses")(app);
Mongoose.connect("mongodb://localhost:27017/example", function(error, database) {
    if(error) {
        return console.log("Could not establish a connection to MongoDB");
    }
    var server = app.listen(3000, function() {
        console.log("Connected on port 3000...");
    });
});

var 몽구스 = require("몽구스");

var Express = require("express");

var 바디파서 = require("body-parser");

var 앱 = Express();

앱.사용(바디파서.json());

몽구스.약속 = 약속;

var 학생 경로 = require("./routes/students")(앱);

var 코스 경로 = require("./routes/courses")(앱);

몽구스.연결("mongodb://localhost:27017/example", 함수(오류, 데이터베이스) {

만약(오류) {

반환 콘솔.로그("MongoDB에 연결할 수 없습니다.");

}

var 서버 = 앱.듣기(3000, 함수() {

콘솔.로그("포트 3000에 연결됨...");

});

위의 코드에서는 이전에 설치한 각 종속성을 가져오고 있습니다. 그런 다음 Express를 초기화하고 요청에서 JSON 본문을 수락하도록 지시하고 있습니다.

이전에 생성한 경로를 Express에 연결해야 하므로 경로를 가져와서 Express 인스턴스를 전달합니다. 마지막으로 몽구스를 통해 MongoDB에 연결이 이루어지고 애플리케이션이 서비스를 시작합니다.

특별히 어렵지 않죠?

Express 프레임워크 및 Couchbase로 API 개발하기

지금까지 Node.js, Mongoose, MongoDB로 API를 만드는 방법을 살펴봤으니 이제 Node.js, Ottoman, Couchbase로 동일한 작업을 수행해야 합니다. 다시 말하지만, 이는 MongoDB에서 Couchbase로 전환하는 것이 얼마나 쉬운지, 그리고 엔터프라이즈급 강력한 NoSQL 데이터베이스의 모든 이점을 얻는 것이 얼마나 쉬운지 보여드리기 위함입니다.

컴퓨터 어딘가에 새 디렉터리를 만들고 그 안에 다음을 실행하여 새 프로젝트를 만듭니다:

npm init --y
npm install express body-parser couchbase ottoman --save

1 2	npm init --y npm 설치 express body-파서 카우치베이스 오스만 --저장

위의 명령은 이전에 보았던 것과 비슷하지만 지금은 Couchbase와 Ottoman을 사용한다는 점을 제외하면 다릅니다. 우리가 빌드하는 프로젝트는 정확히 동일한 구조를 가지며, 다시 한 번 살펴보기 위해 다음과 같이 보입니다:

app.js
routes/
    courses.js
    students.js
models/
    models.js
package.json
node_modules/

app.js

경로/

courses.js

students.js

models/

models.js

package.json

node_modules/

모든 오스만 모델은 모델 디렉터리에 모든 API 엔드포인트와 오스만 로직이 존재합니다. 경로 디렉토리에 존재하며 모든 드라이버 로직은 app.js 파일을 만듭니다.

오스만 모델 정의하기

전환의 용이성을 보여주기 위해 MongoDB 애플리케이션에서 했던 것과 같은 방향으로 작업할 것입니다. 즉, Couchbase Server에서 데이터를 표현할 오스만 모델부터 시작하겠습니다.

프로젝트의 models/models.js 파일을 열고 다음을 포함하세요:

var Ottoman = require("ottoman");

var CourseModel = Ottoman.model("Course", {
    name: { type: "string" },
    term: { type: "string" },
    students: [
        {
            ref: "Student"
        }
    ]
});

var StudentModel = Ottoman.model("Student", {
    firstname: { type: "string" },
    lastname: { type: "string" },
    courses: [
        {
            ref: "Course"
        }
    ]
});

module.exports.StudentModel = StudentModel;
module.exports.CourseModel = CourseModel;

var 오스만 = require("ottoman");

var 코스 모델 = 오스만.모델("코스", {

이름: { 유형: "문자열" },

용어: { 유형: "문자열" },

학생: [

{

ref: "학생"

}

]

});

var 학생 모델 = 오스만.모델("학생", {

이름: { 유형: "문자열" },

성: { 유형: "문자열" },

코스: [

{

ref: "코스"

}

]

});

모듈.수출.학생 모델 = 학생 모델;

모듈.수출.코스 모델 = 코스 모델;

위의 내용은 익숙해 보이지만, 이 두 가지 ODM은 매우 다르다는 것을 알아야 합니다. Mongoose를 통해 MongoDB 스키마를 설계하는 대신 Ottoman을 사용하여 Couchbase용 JSON 모델을 바로 설계할 수 있습니다. Couchbase Buckets에는 스키마가 없다는 것을 기억하세요.

각 오스만 모델에는 속성 집합과 다른 문서를 참조하는 배열이 있습니다. 구문은 약간 다르지만 동일한 목적을 달성합니다.

이제 이러한 모델을 사용하는 API 엔드포인트로 이동합니다.

REST API 엔드포인트 만들기

생성하려는 첫 번째 엔드포인트 세트는 코스 관리와 관련된 것입니다. 프로젝트의 routes/courses.js 파일을 열고 다음 자바스크립트 코드를 포함합니다:

var CourseModel = require("../models/models").CourseModel;

var router = function(app) {

    app.get("/courses", function(request, response) {
        CourseModel.find({}, {load: ["students"]}, function(error, result) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(result);
        });
    });

    app.get("/course/:id", function(request, response) {
        CourseModel.getById(request.params.id, {load: ["students"]}, function(error, result) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(result);
        });
    });

    app.post("/courses", function(request, response) {
        var course = new CourseModel({
            "name": request.body.name
        });
        course.save(function(error, result) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(course);
        });
    });

}

module.exports = router;

var 코스 모델 = require("../모델/모델").코스 모델;

var 라우터 = 함수(앱) {

앱.get("/courses", 함수(요청, 응답) {

코스 모델.찾기({}, {load: ["students"]}, 함수(오류, 결과) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(결과);

});

앱.get("/코스/:ID", 함수(요청, 응답) {

코스 모델.getById(요청.매개변수.id, {load: ["students"]}, 함수(오류, 결과) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(결과);

});

앱.post("/courses", 함수(요청, 응답) {

var 코스 = new 코스 모델({

"name": 요청.body.이름

});

코스.저장(함수(오류, 결과) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(코스);

});

}

모듈.수출 = 라우터;

위의 코드에는 MongoDB 및 Mongoose에서 보았던 것과 거의 동일한 방식으로 구조화된 세 개의 엔드포인트가 있습니다. 하지만 몇 가지 사소한 차이점이 있습니다. 예를 들어, 약속을 사용하는 대신 콜백을 사용하고 있습니다.

가장 눈에 띄는 차이점 중 하나는 쿼리 수행 방식입니다. 저희는 찾기 함수를 사용할 수 있지만, 몽구스에서 보았던 것처럼 getById 함수를 사용할 수 있습니다. 두 시나리오 모두에서 쿼리가 어떻게 발생할 것으로 예상하는지에 대한 정보를 전달할 수 있습니다. 대신 채우기 함수를 사용할 수 있습니다. load 로 로드할 참조 문서를 제공합니다. 몽구스와 오스만의 개념은 매우 유사합니다.

이제 두 번째 경로 세트로 이동합니다. 프로젝트의 경로/학생.js 파일을 열고 다음 자바스크립트 코드를 포함합니다:

var StudentModel = require("../models/models").StudentModel;
var CourseModel = require("../models/models").CourseModel;

var router = function(app) {

    app.get("/students", function(request, response) {
        StudentModel.find({}, {load: ["courses"]}, function(error, result) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(result);
        });
    });

    app.get("/student/:id", function(request, response) {
        StudentModel.getById(request.params.id, {load: ["courses"]}, function(error, result) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(result);
        });
    });

    app.post("/students", function(request, response) {
        var student = new StudentModel({
            "firstname": request.body.firstname,
            "lastname": request.body.lastname
        });
        student.save(function(error, result) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            response.send(student);
        });
    });

    app.post("/student/course", function(request, response) {
        CourseModel.getById(request.body.course_id, function(error, course) {
            if(error) {
                return response.status(401).send({ "success": false, "message": error});
            }
            StudentModel.getById(request.body.student_id, function(error, student) {
                if(error) {
                    return response.status(401).send({ "success": false, "message": error});
                }
                if(!student.courses) {
                    student.courses = [];
                }
                if(!course.students) {
                    course.students = [];
                }
                student.courses.push(CourseModel.ref(course._id));
                course.students.push(StudentModel.ref(student._id));
                student.save(function(error, result) {});
                course.save(function(error, result) {});
                response.send(student);
            });
        });
    })
}

module.exports = router;

var 학생 모델 = require("../모델/모델").학생 모델;

var 코스 모델 = require("../모델/모델").코스 모델;

var 라우터 = 함수(앱) {

앱.get("/학생", 함수(요청, 응답) {

학생 모델.찾기({}, {load: ["코스"]}, 함수(오류, 결과) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(결과);

});

앱.get("/학생/:ID", 함수(요청, 응답) {

학생 모델.getById(요청.매개변수.id, {load: ["코스"]}, 함수(오류, 결과) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(결과);

});

앱.post("/학생", 함수(요청, 응답) {

var 학생 = new 학생 모델({

"이름": 요청.body.이름,

"성": 요청.body.성

});

학생.저장(함수(오류, 결과) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

응답.보내기(학생);

});

앱.post("/학생/코스", 함수(요청, 응답) {

코스 모델.getById(요청.body.course_id, 함수(오류, 코스) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

학생 모델.getById(요청.body.student_id, 함수(오류, 학생) {

만약(오류) {

반환 응답.상태(401).보내기({ "성공": false, "메시지": 오류});

}

만약(!학생.코스) {

학생.코스 = [];

}

만약(!코스.학생) {

코스.학생 = [];

}

학생.코스.push(코스 모델.ref(코스._id));

코스.학생.push(학생 모델.ref(학생._id));

학생.저장(함수(오류, 결과) {});

코스.저장(함수(오류, 결과) {});

응답.보내기(학생);

});

})

}

모듈.수출 = 라우터;

처음 세 개의 엔드포인트가 동일한 형식이라는 것을 이미 알고 있습니다. 관계를 관리하는 마지막 엔드포인트에 주목하고 싶습니다.

이 엔드포인트를 사용하면 ID 값으로 코스를, ID 값으로 학생을 가져옵니다. 둘 다 문서를 반환하는 한, 각각의 배열에 각각의 참조를 추가하고 문서를 다시 저장할 수 있습니다. 몽구스 버전에서도 거의 동일한 코드가 발견되었습니다.

이제 데이터베이스에 연결한 후 애플리케이션 서비스를 시작하는 로직을 살펴볼 수 있습니다.

카우치베이스에 연결하여 애플리케이션 서비스하기

프로젝트의 app.js 파일을 열고 다음 JavaScript를 포함합니다:

var Couchbase = require("couchbase");
var Ottoman = require("ottoman");
var Express = require("express");
var BodyParser = require("body-parser");

var app = Express();
app.use(BodyParser.json());

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");
Ottoman.store = new Ottoman.CbStoreAdapter(bucket, Couchbase);
var studentRoutes = require("./routes/students")(app);
var courseRoutes = require("./routes/courses")(app);
var server = app.listen(3000, function() {
    console.log("Connected on port 3000...");
});

var 카우치베이스 = require("couchbase");

var 오스만 = require("ottoman");

var Express = require("express");

var 바디파서 = require("body-parser");

var 앱 = Express();

앱.사용(바디파서.json());

var 버킷 = (new 카우치베이스.클러스터("couchbase://localhost")).오픈버킷("예제");

오스만.store = new 오스만.CbStoreAdapter(버킷, 카우치베이스);

var 학생 경로 = require("./routes/students")(앱);

var 코스 경로 = require("./routes/courses")(앱);

var 서버 = 앱.듣기(3000, 함수() {

콘솔.로그("포트 3000에 연결됨...");

});

위의 내용이 익숙해 보이시나요? 그렇겠죠! 몽구스 연결 정보를 카우치베이스 연결 정보로 바꾸기만 하면 됩니다. 데이터베이스에 연결하고 나면 애플리케이션 서비스를 시작할 수 있습니다.

결론

몽구스와 몽고DB에서 마이그레이션하는 것은 생각보다 쉽습니다. 사실, y에서 Node.js, Mongoose, MongoDB로 REST API를 빌드한 다음 이를 매우 원활하게 Couchbase로 가져오는 방법을 살펴보았습니다. 특히 백엔드 기술로 Node.js를 사용하는 경우 마이그레이션 프로세스가 두렵지 않다는 것을 증명하기 위한 것이었습니다.

Couchbase를 사용하면 모든 규모에서 작동하는 고성능 분산형 NoSQL 데이터베이스를 확보할 수 있습니다. 데이터베이스 앞에 캐싱을 사용할 필요가 없는데, 이는 Couchbase에 캐싱 기능이 내장되어 있기 때문입니다. Ottoman 사용에 대한 자세한 내용은 이전 블로그 포스팅을 참고하세요. Node.js와 함께 Couchbase를 사용하는 방법에 대한 자세한 내용은 카우치베이스 개발자 포털.

Nic Raboy, 개발자 옹호자, Couchbase

이 문서 공유하기

댓글 하나

N1QL을 사용하여 Node.js와 MongoDB 애플리케이션을 Couchbase로 이동하기 3월 7, 2017에서 11:11 오전

[...] 너무 오래 전에 Mongoose를 사용하는 MongoDB에서 Ottoman을 사용하는 Couchbase로 마이그레이션하는 방법에 대한 글을 썼습니다. 그 튜토리얼의 핵심은 [...]를 공유하는 두 개의 서로 다른 ODM 도구를 Node.js에서 사용하는 것이었습니다.

로그인 하여 답글 남기기
kpal 4월 3, 2018에서 4:02 오전

고마워요 닉 라보이 이렇게 좋은 기사를 작성해 주셔서 감사합니다. 포트 8091의 카우치베이스 UI로 이동하여 내 버킷의 문서를 볼 때 내 스키마의 첫 번째 필드 인 '첫 번째 이름'이 누락 된 필드가 하나 있는데 모든 데이터를 성공적으로 저장하고 있지만 첫 번째 필드 '첫 번째 이름'이 거기에 없습니다. 왜 이런 일이 발생하는지 알고 있습니까? 다른 모든 필드는이 필드 만 표시되지 않습니다. 카우치베이스 또는 오스만과 관련이있을 수 있습니까?

로그인 하여 답글 남기기

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Ottoman을 사용하여 MongoDB Mongoose에서 Couchbase로 마이그레이션하기

요구 사항

NoSQL 데이터 모델 이해

Express 프레임워크와 MongoDB로 API 개발하기

몽구스 스키마 정의하기

REST API 경로 만들기

MongoDB에 연결하고 애플리케이션 서비스하기

Express 프레임워크 및 Couchbase로 API 개발하기

오스만 모델 정의하기

REST API 엔드포인트 만들기

카우치베이스에 연결하여 애플리케이션 서비스하기

결론

받은 편지함에서 카우치베이스 블로그 업데이트 받기

작성자

게시자 Nic Raboy, 개발자 옹호자, Couchbase

댓글 하나

댓글 남기기 응답 취소

카우치베이스 카펠라를 시작할 준비가 되셨나요?

구축 시작

카펠라 무료 사용

연락하기