Migrasi ke Neptune sebagai target Menentukan pengaturan titik akhir untuk target Neptune IAM role untuk mengakses Neptune sebagai target Menentukan aturan pemetaan grafik menggunakan Gremlin dan R2RML*Tipe data untuk migrasi Gremlin dan R2RLL ke Neptune sebagai target Keterbatasan menggunakan Neptune sebagai target

Menggunakan Amazon Neptune sebagai target untuk AWS Database Migration Service

Amazon Neptune adalah layanan basis basis data grafik yang cepat, andal, terkelola sepenuhnya yang membuatnya mudah dalam membangun dan menjalankan aplikasi yang bekerja dengan set data yang sangat terhubung. Inti dari Neptune adalah mesin basis data grafik berperforma tinggi yang dibuat khusus. Mesin ini dioptimalkan untuk menyimpan miliaran hubungan dan membuat kueri grafik dengan latensi milidetik. Neptunus mendukung bahasa query grafik populer ApacheTinkerPopGremlin dan SPARQL W3C. Untuk informasi lebih lanjut tentang Amazon Neptune, lihat Apa itu Amazon Neptune? di Panduan Pengguna Amazon Neptune.

Tanpa basis data grafik seperti Neptune, Anda mungkin memodelkan data yang sangat terhubung dalam basis data relasional. Karena data memiliki koneksi dengan berpotensi dinamis, aplikasi yang menggunakan sumber data tersebut harus memodelkan kueri data terhubung di SQL. Pendekatan ini mengharuskan Anda menulis sebuah lapisan tambahan untuk mengonversi kueri grafik ke SQL. Dan juga, basis data relasional tersedia dengan skema kekakuan. Setiap perubahan dalam skema untuk memodelkan koneksi yang berubah memerlukan downtime dan pemeliharaan tambahan dari konversi kueri untuk mendukung skema baru. Performa kueri juga merupakan hambatan besar lain yang harus dipertimbangkan saat merancang aplikasi Anda.

Basis data grafik dapat menyederhanakan situasi seperti itu secara signifikan. Tidak terikat skema, lapisan kueri yang kaya akan grafik (Gremlin atau SPARQL) dan indeks yang dioptimalkan untuk kueri grafik akan meningkatkan fleksibilitas dan performa. Basis data grafik Amazon Neptune juga memiliki fitur untuk korporasi seperti encryption at rest, lapisan otorisasi aman, backup default, dukungan Multi-AZ, support replika baca, dan lain-lain.

Menggunakan AWS DMS, Anda dapat memigrasi data relasional yang memodelkan grafik yang sangat terhubung ke titik akhir target Neptune dari titik akhir sumber DMS untuk basis data SQL yang didukung.

Untuk detailnya, lihat berikut ini.

Topik

Gambaran umum tentang migrasi ke Amazon Neptune sebagai target
Menentukan pengaturan titik akhir untuk Amazon Neptune sebagai target
Membuat peran layanan IAM untuk mengakses Amazon Neptune sebagai target
Menentukan aturan pemetaan grafik menggunakan Gremlin dan R2RLL untuk Amazon Neptune sebagai target
Tipe data untuk migrasi Gremlin dan R2RLL ke Amazon Neptune sebagai target
Keterbatasan menggunakan Amazon Neptune sebagai target

Gambaran umum tentang migrasi ke Amazon Neptune sebagai target

Sebelum memulai migrasi ke target Neptune, buat sumber daya berikut di akun AWS Anda:

Sebuah klaster Neptune untuk titik akhir target.
Sebuah basis data relasional SQL didukung oleh AWS DMS untuk titik akhir sumber.
Bucket Amazon S3 untuk titik akhir target. Buat bucket S3 ini di Wilayah AWS yang sama dengan klaster Neptune Anda. AWS DMS menggunakan bucket S3 ini sebagai penyimpanan file perantara untuk data target yang sebagian besar dimuat ke basis data Neptune. Untuk informasi selengkapnya tentang cara membuat bucket S3, lihatMembuat emberdi dalamPanduan Pengguna Layanan Penyimpanan Sederhana Amazon.
titik akhir virtual private cloud (VPC) untuk S3 di VPC yang sama seperti klaster Neptune.
Sebuah AWS Identity and Access Management (IAM) role yang mencakup kebijakan IAM. Kebijakan ini harus menentukan izin GetObject, PutObject, DeleteObject dan ListObject ke bucket S3 untuk titik akhir target Anda. Peran ini dijalankan baik oleh AWS DMS dan Neptune dengan akses IAM terhadap kedua target bucket S3 dan basis data Neptune. Untuk informasi lebih lanjut, lihat Membuat peran layanan IAM untuk mengakses Amazon Neptune sebagai target.

Setelah Anda memiliki sumber daya ini, menyiapkan dan memulai migrasi ke target Neptune intinya sama dengan semua migrasi beban penuh menggunakan konsol atau API DMS. Namun, migrasi ke target Neptune memerlukan beberapa langkah unik.

Untuk memigrasi sebuah basis data relasional AWS DMS ke Neptune

Buat instans replikasi seperti yang dijelaskan dalam Membuat instans replikasi.
Buat dan uji basis data relasional SQL yang didukung oleh AWS DMS untuk titik akhir sumber.
Buat dan uji titik akhir target untuk basis data Neptune Anda.

Untuk menghubungkan titik akhir target ke basis data Neptune, tentukan nama server untuk titik akhir klaster Neptune atau titik akhir instans penulis Neptune. Tentukan juga folder bucket S3 untuk AWS DMS yang digunakan untuk menyimpan file perantara untuk beban massal ke basis data Neptune.

Selama migrasi berjalan, AWS DMS menyimpan semua data target yang dimigrasi di dalam folder bucket S3 ini hingga ukuran file maksimum yang Anda tentukan. Ketika penyimpanan file ini mencapai ukuran maksimum tersebut, AWS DMS melakukan pemuatan massal data S3 yang tersimpan ke dalam basis data target. Ia membersihkan folder untuk mengaktifkan penyimpanan data target tambahan apa pun untuk pemuatan berikutnya ke basis data target. Untuk informasi lebih lanjut tentang menentukan pengaturan ini, lihat Menentukan pengaturan titik akhir untuk Amazon Neptune sebagai target.
Buat tugas replikasi beban penuh dengan sumber daya yang dibuat dalam langkah 1-3 dan lakukan hal berikut:
1. Gunakan pemetaan tabel tugas seperti biasa untuk mengidentifikasi skema sumber tertentu, tabel, dan views untuk bermigrasi dari basis data relasional Anda menggunakan pilihan yang tepat dan aturan transformasi. Untuk informasi lebih lanjut, lihat Menggunakan pemetaan tabel untuk menentukan pengaturan tugas.
2. Tentukan pemetaan target dengan memilih salah satu dari berikut ini untuk menentukan aturan pemetaan dari tabel sumber dan tampilan ke grafik basis data target Neptune Anda:
  - Gremlin JSON - Untuk informasi tentang penggunaan Gremlin JSON untuk memuat basis data Neptune, lihat Format memuat data Gremlin di Panduan Pengguna Amazon Neptune.
  - SPARQL RDB to Resource Description Framework Mapping Language (R2RLL) - Untuk informasi tentang menggunakan SPARQL R2RLL, lihat spesifikasi W3C R2RLL: RDB ke bahasa pemetaan RDF.
3. Lakukan salah satu dari berikut ini:
  - Menggunakan konsol AWS DMS, tentukan pilihan pemetaan grafik menggunakan Aturan pemetaan grafik pada halaman Buat tugas migrasi basis data.
  - Menggunakan API AWS DMS, tentukan pilihan ini menggunakan permintaan parameter TaskData dari Panggilan API CreateReplicationTask.
  Untuk informasi lebih lanjut dan contoh penggunaanGremlin JSON dan SPARQL R2RLL dalam menentukan aturan pemetaan grafik, lihat Menentukan aturan pemetaan grafik menggunakan Gremlin dan R2RLL untuk Amazon Neptune sebagai target.
Mulai replikasi untuk tugas migrasi Anda.

Menentukan pengaturan titik akhir untuk Amazon Neptune sebagai target

Untuk membuat atau mengubah titik akhir target, Anda dapat menggunakan konsol atau CreateEndpoint atau Operasi API ModifyEndpoint.

Untuk target Neptune di AWS DMS konsol, tentukan Pengaturan khusus Titik Akhir pada halaman konsol Buat titik akhir atau Ubah titik akhir. Untuk CreateEndpoint dan ModifyEndpoint, tentukan parameter permintaan untuk pilihan NeptuneSettings. Contoh berikut menunjukkan cara melakukannya dengan menggunakan CLI.


dms create-endpoint --endpoint-identifier my-neptune-target-endpoint
--endpoint-type target --engine-name neptune 
--server-name my-neptune-db.cluster-cspckvklbvgf.us-east-1.neptune.amazonaws.com 
--port 8192
--neptune-settings 
     '{"ServiceAccessRoleArn":"arn:aws:iam::123456789012:role/myNeptuneRole",
       "S3BucketName":"my-bucket",
       "S3BucketFolder":"my-bucket-folder",
       "ErrorRetryDuration":57,
       "MaxFileSize":100, 
       "MaxRetryCount": 10, 
       "IAMAuthEnabled":false}‘

Di sini, pilihan CLI --server-name menentukan nama server untuk titik akhir penulis klaster Neptune. Atau Anda dapat menentukan nama server untuk instans titik akhir penulis Neptune.

Berikut adalah parameter permintaan pilihan --neptune-settings:

ServiceAccessRoleArn - (Wajib) Amazon Resource Name (ARN) dari peran layanan yang Anda buat untuk titik akhir target Neptune. Untuk informasi lebih lanjut, lihat Membuat peran layanan IAM untuk mengakses Amazon Neptune sebagai target.
S3BucketName - (Wajib) Nama bucket S3 tempat DMS dapat menyimpan sementara data grafik yang dimigrasikan dalam file .csv sebelum memuatnya secara massal ke basis data target Neptune. DMS memetakan data sumber SQL data grafik sebelum menyimpannya dalam file .csv.
S3BucketFolder - (Wajib) Jalur folder tempat Anda menginginkan DMS untuk menyimpan data grafik yang dimigrasikan di bucket S3 yang ditentukan oleh S3BucketName.
ErrorRetryDuration - (Opsional) Jumlah milidetik waktu tunggu DMS untuk mencoba kembali muatan massal data grafik yang dimigrasikan ke basis data target Neptune sebelum dinyatakan error. Default adalah 250.
MaxFileSize - (Opsional) Ukuran maksimum dalam KB dari data grafik yang dimigrasikan lalu disimpan ke dalam file .csv sebelum DMS memuat data secara massal ke basis data target Neptune. Default adalah 1.048.576 KB (1 GB). Jika berhasil, DMS akan membersihkan bucket, siap untuk menyimpan batch berikutnya dari data grafik yang dimigrasi.
MaxRetryCount - (Opsional) Frekuensi DMS mencoba kembali muatan massal data grafik yang dimigrasikan ke basis data target Neptune sebelum memunculkan error. Default adalah 5.
IAMAuthEnabled - (Opsional) Jika Anda ingin mengaktifkan otorisasi IAM untuk titik akhir ini, atur parameter ini ke true dan lampirkan dokumen kebijakan IAM yang tepat ke peran layanan Anda yang ditentukan oleh ServiceAccessRoleArn. Default adalah false.

Membuat peran layanan IAM untuk mengakses Amazon Neptune sebagai target

Untuk mengakses Neptune sebagai target, buat peran layanan menggunakan IAM. Tergantung pada konfigurasi titik akhir Neptune Anda, lampirkan peran ini pada beberapa atau semua dokumen kepercayaan dan kebijakan IAM berikut. Ketika Anda membuat titik akhir Neptune, peran layanan ini diberikan pada ARN. Melakukan hal ini memungkinkan AWS DMS dan Amazon Neptune untuk mengambil izin untuk mengakses Neptune dan bucket Amazon S3 yang terkait.

Jika Anda mengatur parameter IAMAuthEnabled dalam NeptuneSettings ke true di konfigurasi titik akhir Neptune Anda, lampirkan kebijakan IAM seperti berikut ke peran layanan Anda. Jika Anda mengatur IAMAuthEnabled ke false, Anda dapat mengabaikan kebijakan ini.


// Policy to access Neptune

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "VisualEditor0",
                "Effect": "Allow",
                "Action": "neptune-db:*",
                "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-CLG7H7FHK54AZGHEH6MNS55JKM/*"
            }
        ]
    }

Kebijakan IAM sebelumnya memungkinkan akses penuh ke klaster target Neptune yang ditentukan oleh Resource.

Lampirkan kebijakan IAM seperti berikut ke peran layanan Anda. Kebijakan ini memungkinkan DMS untuk secara sementara menyimpan data grafik yang dimigrasi di bucket S3 yang Anda buat untuk pemuatan massal ke basis data target Neptune.


//Policy to access S3 bucket

{
	"Version": "2012-10-17",
	"Statement": [{
			"Sid": "ListObjectsInBucket0",
			"Effect": "Allow",
			"Action": "s3:ListBucket",
			"Resource": [
				"arn:aws:s3:::my-bucket"
			]
		},
		{
			"Sid": "AllObjectActions",
			"Effect": "Allow",
			"Action": ["s3:GetObject",
				"s3:PutObject",
				"s3:DeleteObject"
			],

			"Resource": [
				"arn:aws:s3:::my-bucket/"
			]
		},
		{
			"Sid": "ListObjectsInBucket1",
			"Effect": "Allow",
			"Action": "s3:ListBucket",
			"Resource": [
				"arn:aws:s3:::my-bucket",
				"arn:aws:s3:::my-bucket/"
			]
		}
	]
}

Kebijakan IAM sebelumnya memungkinkan akun Anda untuk meminta isi bucket S3 (arn:aws:s3:::my-bucket) yang dibuat untuk target Neptune Anda. Hal ini juga memungkinkan akun Anda untuk beroperasi sepenuhnya pada isi semua file bucket dan folder (arn:aws:s3:::my-bucket/).

Edit hubungan kepercayaan dan lampirkan IAM role berikut ke peran layanan Anda untuk mengizinkan AWS DMS dan layanan basis data Amazon Neptune untuk mengambil peran tersebut.


{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "dms.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    },
    {
      "Sid": "neptune",
      "Effect": "Allow",
      "Principal": {
        "Service": "rds.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Untuk informasi tentang penentuan peran layanan ini pada titik akhir target Neptune, lihat Menentukan pengaturan titik akhir untuk Amazon Neptune sebagai target.

Menentukan aturan pemetaan grafik menggunakan Gremlin dan R2RLL untuk Amazon Neptune sebagai target

Aturan pemetaan grafik yang Anda buat menentukan bagaimana data yang diekstrak dari sumber basis data relasional SQL kemudian dimuat ke target klaster basis data Neptune. Format aturan pemetaan ini berbeda tergantung pada apakah aturan untuk memuat data grafik properti menggunakan ApacheTinkerPopGremlin atau Resource Description Framework (RDF) data menggunakan R2RML. Setelah itu, Anda dapat menemukan informasi tentang format ini dan tempat untuk mempelajari selengkapnya.

Anda dapat menentukan aturan pemetaan ini ketika membuat tugas migrasi menggunakan konsol atau API DMS.

Menggunakan konsol, tentukan aturan pemetaan ini dengan menggunakan Aturan pemetaan grafik pada halaman Buat tugas migrasi basisdata. Di Aturan pemetaan grafik, Anda dapat memasukkan dan mengedit aturan pemetaan secara langsung menggunakan editor yang disediakan. Atau Anda dapat menelusuri file yang berisi aturan pemetaan dalam format pemetaan grafik yang sesuai.

Menggunakan API, tentukan pilihan ini berdasarkan permintaan parameter TaskData dari Panggilan API CreateReplicationTask. Atur TaskData ke jalur file yang berisi aturan pemetaan dalam format pemetaan grafik yang sesuai.

Aturan pemetaan grafik untuk menghasilkan data property-graph menggunakan Gremlin

Menggunakan Gremlin untuk menghasilkan data property-graph, menentukan objek JSON dengan aturan pemetaan untuk setiap entitas grafik yang akan dihasilkan dari data sumber. Format JSON ini ditetapkan secara khusus untuk pemuatan massal Amazon Neptune. Templat berikut menunjukkan nampak seperti apa setiap aturan dalam objek ini.



{
    "rules": [
        {
            "rule_id": "(an identifier for this rule)",
            "rule_name": "(a name for this rule)",
            "table_name": "(the name of the table or view being loaded)",
            "vertex_definitions": [
                {
                    "vertex_id_template": "{col1}",
                    "vertex_label": "(the vertex to create)",
                    "vertex_definition_id": "(an identifier for this vertex)",
                    "vertex_properties": [
                        {
                            "property_name": "(name of the property)",
                            "property_value_template": "{col2} or text",
                            "property_value_type": "(data type of the property)"
                        }
                    ]
                }
            ]
        },
        {
            "rule_id": "(an identifier for this rule)",
            "rule_name": "(a name for this rule)",
            "table_name": "(the name of the table or view being loaded)",
            "edge_definitions": [
                {
                    "from_vertex": {
                        "vertex_id_template": "{col1}",
                        "vertex_definition_id": "(an identifier for the vertex referenced above)"
                    },
                    "to_vertex": {
                        "vertex_id_template": "{col3}",
                        "vertex_definition_id": "(an identifier for the vertex referenced above)"
                    },
                    "edge_id_template": {
                        "label": "(the edge label to add)",
                        "template": "{col1}_{col3}"
                    },
                    "edge_properties":[
                        {
                            "property_name": "(the property to add)",
                            "property_value_template": "{col4} or text",
                            "property_value_type": "(data type like String, int, double)"
                        }
                    ]
                }
            ]
        }
    ]
}

Kehadiran label vertex menyiratkan bahwa pembuatan vertex sedang terjadi di sini. Ketiadaannya menyiratkan bahwa vertex dibuat oleh sumber yang berbeda, dan definisi ini hanya menambahkan sifat vertex. Tentukan sebanyak mungkin definisi vertex dan edge yang diperlukan untuk menentukan pemetaan untuk seluruh sumber basis data relasional Anda.

Contoh aturan untuk tabel employee berikut.



{
    "rules": [
        {
            "rule_id": "1",
            "rule_name": "vertex_mapping_rule_from_nodes",
            "table_name": "nodes",
            "vertex_definitions": [
                {
                    "vertex_id_template": "{emp_id}",
                    "vertex_label": "employee",
                    "vertex_definition_id": "1",
                    "vertex_properties": [
                        {
                            "property_name": "name",
                            "property_value_template": "{emp_name}",
                            "property_value_type": "String"
                        }
                    ]
                }
            ]
        },
        {
            "rule_id": "2",
            "rule_name": "edge_mapping_rule_from_emp",
            "table_name": "nodes",
            "edge_definitions": [
                {
                    "from_vertex": {
                        "vertex_id_template": "{emp_id}",
                        "vertex_definition_id": "1"
                    },
                    "to_vertex": {
                        "vertex_id_template": "{mgr_id}",
                        "vertex_definition_id": "1"
                    },
                    "edge_id_template": {
                        "label": "reportsTo",
                        "template": "{emp_id}_{mgr_id}"
                    },
                    "edge_properties":[
                        {
                            "property_name": "team",
                            "property_value_template": "{team}",
                            "property_value_type": "String"
                        }
                    ]
                }
            ]
        }
    ]
}

Di sini, definisi vertex dan edge memetakan hubungan pelaporan dari node employee dengan ID karyawan (EmpID) dan node employee dengan ID manajer (managerId).

Untuk informasi lebih lanjut tentang cara membuat aturan pemetaan grafik menggunakan Gremlin JSON, lihat Format memuat data Gremlin di Panduan Pengguna Amazon Neptune.

Aturan pemetaan grafik untuk menghasilkan data RDF/SPARQL

Jika Anda memuat data RDF untuk dikueri menggunakan SPARQL, tuliskan aturan pemetaan grafik di R2RLL. R2RLL adalah bahasa W3C standar untuk pemetaan data relasional untuk RDF. Dalam satu file R2RMM, sebuah Peta tiga kali lipat (misalnya, pada <#TriplesMap1> berikut) menentukan aturan untuk menerjemahkan setiap baris dari tabel logis ke nol atau lebih tiga kali lipat RDF. Sebuah Peta subjek (misalnya, apa pun dari rr:subjectMap berikut) menentukan aturan untuk menghasilkan subyek dari tiga kali lipat RDF yang dihasilkan oleh peta tiga kali lipat. Sebuah peta predikat-objek (misalnya, apa pun dari rr:predicateObjectMap berikut) adalah fungsi yang menciptakan satu atau lebih pasangan predikat-objek untuk setiap baris tabel logis dari tabel logis.

Contoh sederhana untuk tabel nodes berikut.


@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix ex: <http://example.com/ns#>.

<#TriplesMap1>
    rr:logicalTable [ rr:tableName "nodes" ];
    rr:subjectMap [
        rr:template "http://data.example.com/employee/{id}";
        rr:class ex:Employee;
    ];
    rr:predicateObjectMap [
        rr:predicate ex:name;
        rr:objectMap [ rr:column "label" ];
    ]

Pada contoh sebelumnya, pemetaan mendefinisikan node grafik terpetakan dari tabel karyawan.

Contoh sederhana lain untuk tabel Student berikut.


@prefix rr: <http://www.w3.org/ns/r2rml#>.
@prefix ex: <http://example.com/#>.
@prefix foaf: <http://xmlns.com/foaf/0.1/>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.

<#TriplesMap2>
    rr:logicalTable [ rr:tableName "Student" ];
    rr:subjectMap   [ rr:template "http://example.com/{ID}{Name}";
                      rr:class foaf:Person ];
    rr:predicateObjectMap [
        rr:predicate ex:id ;
        rr:objectMap  [ rr:column "ID";
                        rr:datatype xsd:integer ]
    ];
    rr:predicateObjectMap [
        rr:predicate foaf:name ;
        rr:objectMap  [ rr:column "Name" ]
    ].

Pada contoh sebelumnya, pemetaan mendefinisikan pemetaan node grafikfriend-of-a-friendhubungan antara orang-orang dalamStudentmeja.

Untuk informasi lebih lanjut tentang membuat aturan pemetaan grafik menggunakan SPARQL R2RLL, lihat spesifikasi W3C R2RLL: RDB ke bahasa pemetaan RDF.

Tipe data untuk migrasi Gremlin dan R2RLL ke Amazon Neptune sebagai target

AWS DMS melakukan pemetaan tipe data dari titik akhir sumber SQL Anda ke target Neptune Anda menggunakan salah satu dari dua cara. Cara yang digunakan tergantung pada format pemetaan grafik yang Anda gunakan untuk memuat basis data Neptune:

ApacheTinkerPopGremlin, menggunakan representasi JSON dari data migrasi.
SPARQL W3C menggunakan representasi R2RLL dari data migrasi.

Untuk informasi lebih lanjut tentang dua format pemetaan grafik ini, lihat Menentukan aturan pemetaan grafik menggunakan Gremlin dan R2RLL untuk Amazon Neptune sebagai target.

Selanjutnya, Anda dapat menemukan deskripsi dari pemetaan tipe data untuk setiap format.

Sumber SQL untuk pemetaan ke tipe data target Gremlin

Tabel berikut menunjukkan pemetaan tipe data dari sumber SQL ke target yang sudah diformat GREMLIN.

AWS DMS memetakan semua tipe data sumber SQL yang tidak terdaftar ke Gremlin String.

Tipe data sumber SQL	Tipe data target Gremlin
`NUMERIC` (dan varian)	`Double`
`DECIMAL`	`Double`
`TINYINT`	`Byte`
`SMALLINT`	`Short`
`INT, INTEGER`	`Int`
`BIGINT`	`Long`
`FLOAT`	`Float`
`DOUBLE PRECISION`	`Float`
`REAL`	`Double`
`BIT`	`Boolean`
`BOOLEAN`	`Boolean`
`DATE`	`Date`
`TIME`
`TIMESTAMP`
`CHARACTER` (dan varian)	`String`

Untuk informasi lebih lanjut tentang tipe data Gremlin untuk memuat Neptune, lihat Jenis data Gremlin di Panduan Pengguna Neptune.

Sumber SQL untuk pemetaan ke tipe data target R2RML (RDF)

Tabel berikut menunjukkan pemetaan tipe data dari sumber SQL ke target yang diformat R2RML.

Semua tipe data RDF yang terdaftar adalah case-sensitive, kecuali RDF literal. AWS DMS memetakan tipe data sumber SQL yang tidak terdaftar ke RDF literal.

Sebuah RDF literal adalah salah satu dari berbagai bentuk leksikal literal dan tipe data. Untuk informasi lebih lanjut, lihat literal RDF dalam spesifikasi W3C Resource Description Framework (RDF): Konsep dan Abstrak.

Tipe data sumber SQL	Tipe data target R2RXML (RDF)
`BINARY` (dan varian)	`xsd:hexBinary`
`NUMERIC` (dan varian)	`xsd:decimal`
`DECIMAL`	`xsd:decimal`
`TINYINT`	`xsd:integer`
`SMALLINT`
`INT`, `INTEGER`
`BIGINT`
`FLOAT`	`xsd:double`
`DOUBLE PRECISION`
`REAL`
`BIT`	`xsd:boolean`
`BOOLEAN`	`xsd:boolean`
`DATE`	`xsd:date`
`TIME`	`xsd:time`
`TIMESTAMP`	`xsd:dateTime`
`CHARACTER` (dan varian)	RDF literal

Untuk informasi lebih lanjut tentang tipe data RDF yang digunakan memuat Neptune dan pemetaan mereka ke tipe data sumber SQL, lihat Konversi datatype dalam spesifikasi W3C R2RLL: RDB ke Pemetaan Bahasa RDF.

Keterbatasan menggunakan Amazon Neptune sebagai target

Batasan berikut berlaku saat menggunakan Amazon Neptune sebagai target:

AWS DMS saat ini mendukung tugas beban penuh hanya untuk migrasi ke target Neptune. Migrasi Perubahan pengambilan data (CDC) ke target Neptune tidak didukung.
Pastikan basis data Neptune target Anda dihapus secara manual dari semua data sebelum memulai tugas migrasi, seperti pada contoh berikut.

Untuk drop semua data (vertex dan edge) dalam grafik, jalankan perintah Gremlin berikut.
```
gremlin> g.V().drop().iterate()
```
Untuk drop vertex yang memiliki label 'customer', jalankan perintah Gremlin berikut.
```
gremlin> g.V().hasLabel('customer').drop()
```
catatan
Dibutuhkan beberapa waktu untuk menjatuhkan set data besar. Anda mungkin ingin mengulangi drop() dengan batas, misalnya, limit(1000).

Untuk drop edge yang memiliki label 'rated', jalankan perintah Gremlin berikut.
```
gremlin> g.E().hasLabel('rated').drop()
```
catatan
Dibutuhkan beberapa waktu untuk menjatuhkan set data besar. Anda mungkin ingin mengulangi drop() dengan batas, misalnya limit(1000).
Operasi API DMS DescribeTableStatistics dapat mengembalikan hasil yang tidak akurat tentang tabel yang diberikan karena sifat struktur data grafik Neptune.

Selama migrasi, AWS DMS memindai setiap tabel sumber dan menggunakan pemetaan grafik untuk mengonversi sumber data menjadi grafik Neptune. Data yang dikonversi pertama kali disimpan dalam folder bucket S3 yang ditentukan untuk titik akhir target. Jika sumbernya dipindai dan data S3 perantara ini berhasil dibuat, DescribeTableStatistics mengasumsikan bahwa data berhasil dimuat ke dalam basis data target Neptune. Tapi ini tidak selalu benar. Untuk memverifikasi bahwa data dimuat dengan benar untuk tabel tertentu, bandingkan nilai kembalian count() di kedua ujung migrasi untuk tabel tersebut.

Pada contoh berikut, AWS DMS telah memuat sebuah tabel customer dari basis data sumber, yang diberi label 'customer' dalam grafik basis data target Neptune. Anda dapat memastikan bahwa label ini ditulis ke basis data target. Untuk melakukannya bandingkan jumlah customer baris yang tersedia dari basis data sumber dengan jumlah 'customer' baris berlabel yang dimuat dalam basis data target Neptune setelah tugas selesai.

Untuk mendapatkan jumlah baris pelanggan yang tersedia dari basis data sumber menggunakan SQL, jalankan perintah berikut.
```
select count(*) from customer;
```
Untuk mendapatkan jumlah 'customer' baris berlabel yang dimuat ke dalam grafik basis data target menggunakan Gremlin, jalankan yang berikut ini.
```
gremlin> g.V().hasLabel('customer').count()
```
Saat ini, jika ada satu tabel tunggal yang gagal memuat, maka seluruh tugas gagal. Tidak seperti dalam target basis data relasional, data di Neptune sangat terhubung, yang dalam banyak kasus membuatnya tidak mungkin untuk melanjutkan tugas. Jika tugas tidak dapat dilanjutkan dengan sukses karena tipe kegagalan memuat data seperti ini, maka buatlah tugas baru untuk memuat tabel yang gagal dimuat. Sebelum menjalankan tugas baru ini, secara manual kosongkan tabel sebagian dimuat dari target Neptune.

catatan
Anda dapat melanjutkan tugas yang gagal migrasi ke target Neptune jika kegagalan masih dapat dipulihkan (misalnya, kesalahan transit jaringan).
AWS DMS mendukung sebagian besar standar untuk R2RLL. Namun AWS DMS tidak mendukung standar R2RLL tertentu, termasuk inverse expression, joins, dan views. Sebuah solusi untuk view R2RLL adalah dengan membuat view SQL kustom yang sesuai dalam basis data sumber. Dalam tugas migrasi, gunakan pemetaan tabel untuk memilih view sebagai masukan. Kemudian petakantampilan ke tabel yang kemudian dikonsumsi oleh R2RLM untuk menghasilkan data grafik.
Ketika Anda memigrasi data sumber dengan tipe data SQL yang tidak didukung, data target yang dihasilkan dapat kehilangan ketepatan. Untuk informasi selengkapnya, lihat Tipe data untuk migrasi Gremlin dan R2RLL ke Amazon Neptune sebagai target.
AWS DMStidak mendukung migrasi data LOB ke target Neptunus.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Menggunakan Amazon DocumentDB sebagai target

Menggunakan Redis sebagai target

Menggunakan Amazon Neptune sebagai target untuk AWS Database Migration Service

Topik

Gambaran umum tentang migrasi ke Amazon Neptune sebagai target

Untuk memigrasi sebuah basis data relasional AWS DMS ke Neptune

Menentukan pengaturan titik akhir untuk Amazon Neptune sebagai target

Membuat peran layanan IAM untuk mengakses Amazon Neptune sebagai target

Menentukan aturan pemetaan grafik menggunakan Gremlin dan R2RLL untuk Amazon Neptune sebagai target

Aturan pemetaan grafik untuk menghasilkan data property-graph menggunakan Gremlin

Aturan pemetaan grafik untuk menghasilkan data RDF/SPARQL

Tipe data untuk migrasi Gremlin dan R2RLL ke Amazon Neptune sebagai target

Sumber SQL untuk pemetaan ke tipe data target Gremlin

Sumber SQL untuk pemetaan ke tipe data target R2RML (RDF)

Keterbatasan menggunakan Amazon Neptune sebagai target

catatan

catatan

catatan