Big Data : Hadoop with NoSQL

2,634 views

Published on

Published in: Technology
2 Comments
10 Likes
Statistics
Notes
No Downloads
Views
Total views
2,634
On SlideShare
0
From Embeds
0
Number of Embeds
27
Actions
Shares
0
Downloads
0
Comments
2
Likes
10
Embeds 0
No embeds

No notes for slide
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • \n
  • Big Data : Hadoop with NoSQL

    1. 1. THE BIG DATA :
    2. 2.  Hadoop
    3. 3.  with
    4. 4.  NoSQL 서울대학교 의생명지식공학 연구실 정 진욱 cool_uk@bike.snu.ac.kr
    5. 5. PUTING CLOUD BIG
    6. 6.  DA COMPUTING
    7. 7. 분산처리 서버
    8. 8.  가상화 PaaS보안 스토리지
    9. 9.  가상화 데이터
    10. 10.  분석 Object
    11. 11.  Storage 등등등
    12. 12.  ..
    13. 13. 분산처리 서버
    14. 14.  가상화 PaaS보안 스토리지
    15. 15.  가상화 데이터
    16. 16.  분석 Object
    17. 17.  Storage 등등등
    18. 18.  ..
    19. 19. + + =USERS SMART SERVICE RAW PHONE DATA
    20. 20. “주어진
    21. 21.  시스템에서
    22. 22.  처리할
    23. 23.  수
    24. 24.  있는
    25. 25.  비용,
    26. 26.  혹은
    27. 27.  시간의
    28. 28.  범위를
    29. 29.  벗어나는
    30. 30.  데이터”
    31. 31. 하둡에
    32. 32.  대해서
    33. 33. +200
    34. 34.  COMPANIES
    35. 35. 오늘은 과식을 했더니 배가 아프다. 오늘은 배가 아파 소화제를 먹어야겠다. 내일은 배가 괜찮아질까? MAP Phase Reduce Phase 오늘은 배가 아파 소화제를 먹어야겠다. 오늘, 1 오늘, 1 내일, 1 과식, 1 배, 1 배, 1 배, 1 소화제, 1 오늘은 과식을 했더니 배가 아프다.내일은 배가 괜찮아질까? Merge/Sort node 1 node 2 node 3 내일(1) 오늘 (2) 내일, 1 오늘, 1 오늘, 1 배(3) 배, 1 과식, 1 배, 1 소화제(1) 배, 1 소화제, 1
    36. 36. Hadoop Distributed File System가상
    37. 37.  파일시스템
    38. 38. Hadoop Distributed File Systemnode 1 node 2 node 3 node 4 node 5 node 6
    39. 39. *HUGE* FILE 블럭단위의 분산 저장 HDFSnode 1 node 2 node 3 node 4 node 5 node 6
    40. 40. 데이터
    41. 41.  관리 작업
    42. 42.  관리 NameNode JobTracker DataNode TaskTracker
    43. 43. Master NameNode node 1 node 2 node 3 node 4 node 5 node 6◎
    44. 44.  HDFS의
    45. 45.  Master
    46. 46.  역할 ◎
    47. 47.  주로
    48. 48.  메모리/IN-Output
    49. 49.  작업 -
    50. 50.  Slave(Datanode)에게
    51. 51.  작업
    52. 52.  지시 ◎
    53. 53.  NameNode
    54. 54.  문제시 -
    55. 55.  각
    56. 56.  블록별
    57. 57.  노드
    58. 58.  위치
    59. 59.  저장
    60. 60.  
    61. 61.  
    62. 62.  
    63. 63.  시스템
    64. 64.  전체
    65. 65.  문제
    66. 66.  발생 -
    67. 67.  분산파일
    68. 68.  시스템의
    69. 69.  상태
    70. 70.  파악
    71. 71. Master node 1 node 2 node 3 node 4 node 5 node 6 DataNode◎
    72. 72.  HDFS의
    73. 73.  각
    74. 74.  Slave
    75. 75.  Node에
    76. 76.  존재◎
    77. 77.  HDFS블록을
    78. 78.  기록
    79. 79.  -
    80. 80.  파일
    81. 81.  읽기
    82. 82.  수행
    83. 83. text-1.txt {1, 2, 3 } Master text-2.txt {4, 5 } Namenode Datanodes node 1 node 2 node 3 3 2 11 2 3 node 4 node 5 node 6 4 1 5 2 4 5 3
    84. 84. text-1.txt {1, 2, 3 } Master text-2.txt {4, 5 } Namenode Datanodes node 1 node 2 node 3 3 2 11 2 3 node 4 node 5 node 6 4 1 5 2 4 5 3
    85. 85. Master JobTracker node 1 node 2 node 3 node 4 node 5 node 6◎
    86. 86.  Master에서
    87. 87.  작업관리 ◎
    88. 88.  작업
    89. 89.  모니터링
    90. 90.   -
    91. 91.  작업
    92. 92.  실패시
    93. 93.  재실행
    94. 94.  등◎
    95. 95.  실행계획
    96. 96.  결정 -
    97. 97.  어떤
    98. 98.  데이터
    99. 99.  파일을
    100. 100.  처리할지
    101. 101.  결정 -
    102. 102.  노드에
    103. 103.  작업
    104. 104.  할당
    105. 105. Master node 1 node 2 node 3 node 4 node 5 node 6 TaskTracker◎
    106. 106.  각
    107. 107.  Slave
    108. 108.  Node에
    109. 109.  존재◎
    110. 110.  각
    111. 111.  Slave
    112. 112.  Node에
    113. 113.  할당된
    114. 114.  작업
    115. 115.  실행
    116. 116. Master JobTracker 분할
    117. 117.  작업
    118. 118.  지시TaskTrackersMapReduce
    119. 119.  작업
    120. 120.  종료
    121. 121.  후
    122. 122.  응답JobTracker와
    123. 123.  지속적
    124. 124.  통신 node 1 node 2 node 3 TaskTracker TaskTracker TaskTracker Map Map Map Reduce Reduce Reduce
    125. 125. Master NameNode JobTrackernode 1 node 2 node 3DataNode DataNode DataNodeTaskTracker TaskTracker TaskTracker
    126. 126. NoSQL에
    127. 127.  대해서
    128. 128. 전통적 방식의 RDBMS를 놔두고왜
    129. 129.  
    130. 130.  
    131. 131.  
    132. 132.  
    133. 133.  NoSQL을
    134. 134.  사용하는가?
    135. 135. 전통적 방식의 RDBMS를 놔두고왜
    136. 136.  
    137. 137.  
    138. 138.  
    139. 139.  
    140. 140.  NoSQL을
    141. 141.  사용하는가?*
    142. 142.  NoSQL이
    143. 143.  완전하게
    144. 144.  RDBMS를
    145. 145.  
    146. 146.  
    147. 147.  대체
    148. 148.  할
    149. 149.  순
    150. 150.  없습니다
    151. 151. Facebook
    152. 152. 하루 10억 쿼리5억명 이상의 매해 74% 성장 사용자 20분당 270만건 이상의 채팅 메세지
    153. 153. Twitter
    154. 154. 하루 8억 쿼리 4억 6천만명 하루 45만개의이상의 사용자 계정 생성 하루 1억 8천만개의 트윗
    155. 155. Government
    156. 156. 기상데이터기타 수많은 교통정보공공데이터 매일매일
    157. 157.  쌓이는 엄청난
    158. 158.  수의
    159. 159.  데이터
    160. 160. Heavy
    161. 161.  RequestSNS등의
    162. 162.  인터넷
    163. 163.  서비스의
    164. 164.  엄청난
    165. 165.  성장세 =
    166. 166.  데이터
    167. 167.  저장소의
    168. 168.  확장
    169. 169.  필요 =
    170. 170.  쿼리
    171. 171.  처리
    172. 172.  요구량
    173. 173.  증가
    174. 174.  필요
    175. 175. Scale Up Scale Out 데이터베이스
    176. 176.  증축 -
    177. 177.  서비스
    178. 178.  요구
    179. 179.  수준
    180. 180.  내에서
    181. 181.  증축
    182. 182.  할
    183. 183.  수록 쿼리
    184. 184.  처리량이
    185. 185.  늘어나야
    186. 186.  함
    187. 187. RDBMS◎
    188. 188.  테이블간의
    189. 189.  관계정의
    190. 190.  모델링◎
    191. 191.  원자성/일관성/고립성/지속성의
    192. 192.  트랜젝션
    193. 193.  보장◎
    194. 194.  위
    195. 195.  두가지를
    196. 196.  유지한채
    197. 197.  Scale-out
    198. 198.  필요
    199. 199. RDBMS의
    200. 200.  Scale-Out
    201. 201.  문제점(1)◎
    202. 202.  테이블간의
    203. 203.  관계정의
    204. 204.  모델링◎
    205. 205.  원자성/일관성/고립성/지속성의
    206. 206.  트랜젝션
    207. 207.  보장 Data Locking Problem =
    208. 208.  Lock
    209. 209.  숫자
    210. 210.  상승 =
    211. 211.  시스템
    212. 212.  부하
    213. 213.  상승 =
    214. 214.  현저히
    215. 215.  떨어지는
    216. 216.  효율
    217. 217. RDBMS의
    218. 218.  Scale-Out
    219. 219.  문제점(2) Split◎
    220. 220.  (1)의
    221. 221.  문제
    222. 222.  해결을
    223. 223.  위해
    224. 224.  큰
    225. 225.  테이블을
    226. 226.  여러대의
    227. 227.  
    228. 228.  
    229. 229.  
    230. 230.  
    231. 231.  DBMS서버에
    232. 232.  나누어
    233. 233.  서비스(Sharding) -
    234. 234.  개발자/응용
    235. 235.  프로그램이
    236. 236.  DB
    237. 237.  instance별
    238. 238.  테이블
    239. 239.  Mapping
    240. 240.  관계를
    241. 241.  알아야
    242. 242.  함
    243. 243.   -
    244. 244.  처리량에
    245. 245.  따른
    246. 246.  Shard
    247. 247.  재분배
    248. 248.  필요 -
    249. 249.  변경/재분배시
    250. 250.  Mapping이
    251. 251.  다시
    252. 252.  이루어져야
    253. 253.  함
    254. 254. NoSQL은
    255. 255.  어떻게
    256. 256.  이
    257. 257.  문제를
    258. 258.  해결하는가? ◎
    259. 259.  RDBMS의
    260. 260.  Relationship과
    261. 261.  Join을
    262. 262.  
    263. 263.  
    264. 264.  
    265. 265.  Linking과
    266. 266.  Embedded로
    267. 267.  구현 ◎
    268. 268.  자유로운
    269. 269.  스키마 ◎
    270. 270.  Key-Value
    271. 271.  등의
    272. 272.  기반
    273. 273.  데이터
    274. 274.  모델링으로
    275. 275.  
    276. 276.  
    277. 277.  
    278. 278.  
    279. 279.  트랜젝션
    280. 280.  구조를
    281. 281.  느슨하게
    282. 282.  함
    283. 283. 사용자가
    284. 284.  작성한
    285. 285.  블로그
    286. 286.  글과
    287. 287.  태그를 데이터
    288. 288.  베이스로
    289. 289.  표현한다면RDBMS * * * * users posts tagsNoSQL(key-value
    290. 290.  oriented) {
    291. 291.  
    292. 292.  
    293. 293.  “id”
    294. 294.  :
    295. 295.  ObjectId(“123qweasd”),
    296. 296.  
    297. 297.  
    298. 298.  “user”
    299. 299.  :
    300. 300.  “jinuk”,
    301. 301.  
    302. 302.  
    303. 303.  
    304. 304.  “posts”
    305. 305.  :
    306. 306.  [{
    307. 307.  
    308. 308.  
    309. 309.  
    310. 310.  
    311. 311.  
    312. 312.  
    313. 313.  
    314. 314.  
    315. 315.  
    316. 316.  
    317. 317.  
    318. 318.  
    319. 319.  
    320. 320.  
    321. 321.  
    322. 322.  
    323. 323.  
    324. 324.  
    325. 325.  
    326. 326.  
    327. 327.  “오늘은
    328. 328.  배가
    329. 329.  고프다”,
    330. 330.  “tags”
    331. 331.  :
    332. 332.  [
    333. 333.  “허기”,
    334. 334.  “식사”
    335. 335.  ],
    336. 336.  
    337. 337.  
    338. 338.  
    339. 339.  
    340. 340.  
    341. 341.  
    342. 342.  
    343. 343.  
    344. 344.  
    345. 345.  
    346. 346.  
    347. 347.  
    348. 348.  
    349. 349.  
    350. 350.  
    351. 351.  
    352. 352.  
    353. 353.  
    354. 354.  
    355. 355.  
    356. 356.  “잠이
    357. 357.  온다’,
    358. 358.  “tags”
    359. 359.  :
    360. 360.  [“잠”,
    361. 361.  “피곤”,
    362. 362.  “밤샘”]
    363. 363.  
    364. 364.  
    365. 365.  
    366. 366.  
    367. 367.  
    368. 368.  
    369. 369.  
    370. 370.  
    371. 371.  
    372. 372.  
    373. 373.  
    374. 374.  
    375. 375.  
    376. 376.  
    377. 377.  
    378. 378.  
    379. 379.  
    380. 380.  
    381. 381.  }] }
    382. 382. 사용자가
    383. 383.  작성한
    384. 384.  블로그
    385. 385.  글과
    386. 386.  태그를 데이터
    387. 387.  베이스로
    388. 388.  표현한다면RDBMS * * * * users posts tags DBMS에
    389. 389.  비해
    390. 390.  훨씬
    391. 391.  느슨해진NoSQL(key-value
    392. 392.  oriented) 구조와
    393. 393.  관계 {
    394. 394.  
    395. 395.  
    396. 396.  “id”
    397. 397.  :
    398. 398.  ObjectId(“123qweasd”),
    399. 399.  
    400. 400.  
    401. 401.  “user”
    402. 402.  :
    403. 403.  “jinuk”,
    404. 404.  
    405. 405.  
    406. 406.  
    407. 407.  “posts”
    408. 408.  :
    409. 409.  [{
    410. 410.  
    411. 411.  
    412. 412.  
    413. 413.  
    414. 414.  
    415. 415.  
    416. 416.  
    417. 417.  
    418. 418.  
    419. 419.  
    420. 420.  
    421. 421.  
    422. 422.  
    423. 423.  
    424. 424.  
    425. 425.  
    426. 426.  
    427. 427.  
    428. 428.  
    429. 429.  
    430. 430.  “오늘은
    431. 431.  배가
    432. 432.  고프다”,
    433. 433.  “tags”
    434. 434.  :
    435. 435.  [
    436. 436.  “허기”,
    437. 437.  “식사”
    438. 438.  ],
    439. 439.  
    440. 440.  
    441. 441.  
    442. 442.  
    443. 443.  
    444. 444.  
    445. 445.  
    446. 446.  
    447. 447.  
    448. 448.  
    449. 449.  
    450. 450.  
    451. 451.  
    452. 452.  
    453. 453.  
    454. 454.  
    455. 455.  
    456. 456.  
    457. 457.  
    458. 458.  
    459. 459.  “잠이
    460. 460.  온다’,
    461. 461.  “tags”
    462. 462.  :
    463. 463.  [“잠”,
    464. 464.  “피곤”,
    465. 465.  “밤샘”]
    466. 466.  
    467. 467.  
    468. 468.  
    469. 469.  
    470. 470.  
    471. 471.  
    472. 472.  
    473. 473.  
    474. 474.  
    475. 475.  
    476. 476.  
    477. 477.  
    478. 478.  
    479. 479.  
    480. 480.  
    481. 481.  
    482. 482.  
    483. 483.  
    484. 484.  }] }
    485. 485. NoSQL은
    486. 486.  어떻게
    487. 487.  이
    488. 488.  문제를
    489. 489.  해결하는가? ◎
    490. 490.  RDBMS의
    491. 491.  Relationship과
    492. 492.  Join을
    493. 493.  
    494. 494.  
    495. 495.  
    496. 496.  Linking과
    497. 497.  Embedded로
    498. 498.  구현 ◎
    499. 499.  자유로운
    500. 500.  스키마 ◎
    501. 501.  Key-Value
    502. 502.  등의
    503. 503.  기반
    504. 504.  데이터
    505. 505.  모델링으로
    506. 506.  
    507. 507.  
    508. 508.  
    509. 509.  
    510. 510.  트랜젝션
    511. 511.  구조를
    512. 512.  느슨하게
    513. 513.  함 -
    514. 514.  Scale-Out의
    515. 515.  용이성
    516. 516.  취득
    517. 517.  
    518. 518.  
    519. 519.  
    520. 520.  
    521. 521.  
    522. 522.  
    523. 523.  RDBMS에
    524. 524.  비해
    525. 525.  저렴한
    526. 526.  비용
    527. 527.  
    528. 528.  
    529. 529.  
    530. 530.  
    531. 531.  
    532. 532.  
    533. 533.  Memory
    534. 534.  Mapping
    535. 535.  기능으로
    536. 536.  빠른
    537. 537.  R/W
    538. 538. NoSQL이
    539. 539.  할
    540. 540.  수
    541. 541.  없는
    542. 542.  것들 ◎
    543. 543.  강한
    544. 544.  트랜젝션
    545. 545.  미지원 ◎
    546. 546.  데이터
    547. 547.  일관성의
    548. 548.  미고려 ◎
    549. 549.  데이터
    550. 550.  무결성
    551. 551.  고려하지
    552. 552.  않음 ◎
    553. 553.  복잡한
    554. 554.  쿼리
    555. 555.  미지원 ◎
    556. 556.  Key
    557. 557.  단위의
    558. 558.  읽기/쓰기만
    559. 559.  지원하는
    560. 560.  경우가
    561. 561.  많음
    562. 562.  
    563. 563.  
    564. 564.  
    565. 565.  
    566. 566.  
    567. 567.  
    568. 568.  서비스에
    569. 569.  따른
    570. 570.  시스템
    571. 571.  선택
    572. 572.  필요
    573. 573. NoSQL
    574. 574.  또한
    575. 575.  수많은
    576. 576.  종류
    577. 577.  존재
    578. 578. 하루에도
    579. 579.  수많은
    580. 580.  insert가
    581. 581.  이루어지는
    582. 582.  데이터에
    583. 583.  활용 기상데이터 교통정보 기타 수많은 데이터
    584. 584. Hadoop
    585. 585.  Ecosystem
    586. 586. Hadoop NoSQLHadoop과
    587. 587.  NoSQL이
    588. 588.  빅데이터의
    589. 589.  모든것은
    590. 590.  아니지만
    591. 591.  ..
    592. 592. Q/A

    ×