[1028 JPA ] 2022.05.25
[1028 SQL] 2022.04.01
[1028 데이터베이스] 데이터베이스 기본 작성중 2021.08.16
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 16]EsperTech 2021.05.27
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 15]Storm 2021.05.27
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 14]redis 2021.05.27
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 13]HBase 2021.05.27
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 12]적재-실시간 로그/분석 2021.05.27
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 11]주키퍼 2021.05.26
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 10]하둡 2021.05.26
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 09]적재-대용량로그파일 2021.05.26
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 08]수집- 카프카 2021.05.24
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 07]수집- 플럼 2021.05.24
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 06]수집- 개요/아키텍처 2021.05.24
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 05]하둡, 주키퍼 명령어 2021.05.24
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 04] 빅데이터 클러스터 구성 2021.05.22
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 03] 서버설정 크라우데라 설치 2021.05.21 (2)
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 02] 소프트웨어/하드웨어 2021.05.18 (2)
[1028 from 실무로 배우는 빅데이터 기술 By 김강원 01] 도메인이해 2021.05.18
[1028 from 점프 투 파이썬, 부스트캠프]Python 2021.05.02
728x90

JPA 프로그래밍 입문 초반에 읽어서 조금 이해가 가기시작했는데 내용이 주관적인부분이 보여 자바ORM 표준 JPA 프로그래밍 으로 갈아탔습니다. 대부분의 내용이  "자바ORM 표준 JPA 프로그래밍 " 내용입니다. 

 

내용 출처 :
http://mobile.kyobobook.co.kr/showcase/book/KOR/9788960777330?OV_REFFER=https://www.google.com/

 

자바 ORM 표준 JPA 프로그래밍 - 교보문고

스프링 데이터 예제 프로젝트로 배우는 전자정부 표준 데이터베이스 프레임 | ★ 이 책에서 다루는 내용 ★■ JPA 기초 이론과 핵심 원리■ JPA로 도메인 모델을 설계하는 과정을 예제 중심으로

www.kyobobook.co.kr


http://www.yes24.com/Product/Goods/41787023

 

JPA 프로그래밍 입문 - YES24

JPA는 Java Persistence API의 약자로 자바 ORM 스펙(specification)이다. JPA는 하이버네이트를 개발한 가빈 킹(Gavin King)이 주도적으로 참여하여 만든 표준으로 1.0과 2.0을 거쳐 현재 2.1 버전까지 나온 상태이

www.yes24.com

JPA 기본개념. 

JPA 기본개념. 
JPA Java Persistence API
Java진영 ORM 기술 표준.

Entity 분석, SQL 생성, JDBC API 사용, 패러다임 불일치 해결.

하이버네이트 개발한 가빈 킹 이 주도적으로 참여 만든 표준 .
JPA 1.0 2006년 : 초기버전, 복합키, 연관관계기능 부족
JPA 2.0 2009년 : 대부분의 ORM 기능 포함하고 JPA Criteria가 추가
JPA 2.1 2013년: 스토어드 프로시져 접근, 컨버터, 엔티티 그래프 기능 추가. cf) java8 2014년, Hibernate5 2017년
JPA 2.4 의 hibernate 5.4.31(2021)

장점
생산성, 유지보수, 패러다임 불일치 해결, 성능(재사용)
데이터 접근 추상화, 벤더 독립성(다른종료 DB사용가능)

1. SQL 기존 문제점 : 반복(CRUD 계속 작성), SQL의존적 개발(필드 수정시 전체 수정, 엔티티를 신뢰할수없다), JPA와 문제해결.
2. 패러다임 불일치 : 상속(persist 1회로 해결), 연관관계(FK), 객체 그래프 탐색(지연로딩), 비교(find())
JPA 구현체 = JPA 프로바이더 = ORM 프레임워크
Hibernate 하이버네이트 << 이거 보통 사용.
EclipseLink 이클립스링크
DataNucleus 데이터 핵심(데이터 뉴클리어스)
* provider 제공자.
jpa 사용 핵심 라이브러리
hibernate-core.jar
hibernate.jpa2.1.api.jar

코드구성
1. 엔티티 메니저 팩토리 설정(EntityManagerFactory)
- 설정정보조회(persistence.xml) -> 생성(Persistence) ->생성(EntityManagerFactory) ->EntitiyManager
- 커넥션 풀도 생성하므로 비용이 아주큼, 애플리케이션 전체에서 딱한번 생성하고 공유해서 사용.
- 엔티티 매니저는 데이터베이스 커넥션과 밀접한 관계, 스레드간 공유하거나 재사용 안됨.
-사용이 끝난 엔티티 매니저는 반드시 종료, 인티티 매니저 팩토리도 반드시 종료.
2. 트랜젝선관리
3. 비지니스 로직
.persist()
.setXXX(value) :update : 변경감지(dirty checking): 플러시 호출->엔티티 스냅샷 비교=>변경되면 수정쿼리 쓰기지연 SQL 저장소 보냄. =>데이터베이스 보냄=>데이터베이스의 트랜잭션 커밋. 영속상태에서만 적용됨.
.remove()
.find(XX.class, id)
persistence context jpa가 관리하는 엔티티 객체 집합,
엔티티객체 DB 반영, DB에서 읽어온 데이터 어플리케이션에 제공
영속 콘텍스트에 보관된 객체를 persistent object 라고 부른다.
세션 단위로 생김

응용프로그램(엔티티객체) -> (EntityManger )-> 영속컨텍스트(영속객체) -> DB(레코드)
응용프로그램(엔티티객체) <- (EntityManger )<- 영속컨텍스트(영속객체) <- DB(레코드)

영속 컨텍스트 : 엔티티 타입 +식별자 키로 사용하는 일종의 보관소.
JEE 컨테이너를 사용하면 실행환경에 따라 여러 EntityManager 가 한 개의 영속 컨텍스트를 공유할수도 있다. 캐시 공유.

1. EntityManagerFactory emf = Persistence.createEntityManagerFactory() ;
EntityManager em = emf.createEntityManager(); : EntityManager 생성
2. ENtityTransaction trans = em.getTransaction();
trans.beging() : 트랜잭션 시작
3. User user = new User();
em.persist(user); :EntityManager를 통해 영속 컨텍스트에 객체 추가하거나 구한다.
4. trans.commit(); / trans.rollback() :트랜젝션 커밋
5. em.close() : EntityManager 닫기.


User user = entityManager.find(User.class, "A@A.com"); user 엔티티의 아이디 A@A.com 찾기

 

환경설정 & 기본 코드
apllication.xml 전용속성
hibernate.show_sql :SQL 출력
hibernate.format_sql: 자동정렬 출력
hibernate.use_sql_commentss: 주석도 같이 출력
hibernate.id.new_generator_mapping: false(default) : jpa 표준에 맞춘 새로운 키 생성 전략을 사용. allocationSize 속성사용바뀜
hibernate.hbm2ddl.auto :
- create(스키마 자동생성)
- create-drop(create속성 + 종료후 생성한 DDL 제거 : drop +create+drop)
- update(변경사항만 수정)
- validate(변경사항 있으면 경고를 남기고 어플리케이션 실행안함)
- none(자동 생성기능을 사용하지 않음, 속성자체를 삭제 or 유효하지 않은 값 입력.)
jpa.hibernate.naming.physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl : 카멜 -> 스네이크
spring.jpa.hibernate.use-new-id-generator-mappings =true : 키 생성 전략시, false 일 겨우 기존 하비어네이트 시스템 유지보수. true 설정시 allocatonSize 속성 사용방식 달라짐.
** 운영주의 사항 : create, create-drop, update 옵션 사용 불가 개발단계에서만
*개발시 초기 create, update, 자동화테스트 ci서버 create or create-drop, 테스트 서버 update or validate, 스테이징, 운영은 validate or none
JPA2.1부터 스키마 자동생성기능 표준으로 지원. 하지만 update, validate 옵션은 지원하지 않음. ????


JPA 어노테이션 패키지 위치
import javax.persistence.*;

JPA 실행 위한 기본 설정파일
persistence.xml
- 구현체들이 자동으로 엔티티 인식못할때 설정가능, JPA 표준속성, 하이버네이트 속성 외
- persistence-unit : DB 이름 그와 관련 DB 설정
커넥션 풀 설정 spring.datasource.hikari.connection-timeout = 20000 : 최대 커넥션 수n
spring.datasource.hikari.minimum-idle= 10 : #HikariCP 사용 유지 최소 커넥션 수
spring.datasource.hikari.maximum-pool-size= 10 : 최대 풀 사이즈
spring.datasource.hikari.idle-timeout=10000 : 최대 유휴(대기)시간
spring.datasource.hikari.max-lifetime= 1000 : 종료 후 최대 연결 시간
spring.datasource.hikari.auto-commit =true : 자동 커밋 기본설정


https://www.javadevjournal.com/spring-boot/spring-boot-hikari/#:~:text=a%20connection%20spring.-,datasource.,in%20a%20connection%20pool%20spring.
방언 dialect 방언 표준 아닐때 사용
spring.jooq.sql-dialect
https://wannaqueen.gitbook.io/spring5/spring-boot/undefined-1/31.-sql-by-ys/31.6-jooq

데이터 타입
- 가변문자 타입 MySQL(VARCHAR), 오라클(VARCHAR2)
- 숫자 타입 MySQL(integer), 오라클(Number)
다른 함수명
- SQL표준(SUBSTRING()), 오라클(SUBSTR())
페이징 처리
- MySQL(LIMIT), 오라클(ROWNUM

Hibernate- 현재 45개 데이터베이스 방언 지원. )
엔티티 엔티티
(사전) 독립체, 인간이 생각하는 개념 또는 정보의 세계에서는 의미있는 정보의 단위

엔티티 매니저 팩토리
- DB 갯수만큼
- 엔티티 매니저 팩토리는 스레드 세이프, 엔티티 매니저는 동시성 문제, 스레드간 공유 안됨.
- 하는일
1. 에플리케이션에서 관리- 직접 생성, 종료
2. 컨테이너에서 관리 - JBoss EAP, 웹로직, TomEE와 같은 JEE 컨테이너

영속성 컨텍스트
- 엔티티를 영구 저장하는 환경.
- 개념적, 엔티티 매니저 생성할 때 하나 만들어짐, 엔티티 매니저를 통해서 영속성 컨텍스트에 접근가능, 관리
- 기본적으로 하나의 엔티티 매니저에 하나의 영속성 컨텍스트 만듬.


* 엔티티매니저 팩토리 코드
public T find(Class entityClass, Object primaryKey);
먼저 1차 캐시에서 엔티티를 찾고 만약 찾는 엔티티가 1차 캐시에 없으면 데이터베이스에서 조회 한다.
존재하지 않으면 null
1차캐시 - 어플리케이션 수준의 캐시.
조회 -> 1차캐시없으면 데이터베이스 조회->조회 데이터로 엔티티 생성, 1차 캐시 저장-> 조회한 엔티티 반환
==>동일성, 동등성 모두 같은이유 , Repeatable read 등급 트랜잭션 격리 수준을 제공

public T getReference(Class entityClass, Object primaryKey);
존재하지 않으면 EntityNotFoundException
쿼리를 바로 실행하지 않고 프록시 객체를 리턴, 프록시 객체는 최초 데이터가 필요한 시점에 select 쿼리를 실행.
세션 범위 밖에서 첫 실행시 ({}) getFiled 실행시 LazyInitializationException -no Session 발생

public void persist(Object entity);
쓰기지연(transactional write-behind) : 트랜젝션 커밋 직전까지 데이터베이스에 엔티티를 저장하지 않고 내부 쿼리 저장소에 insert 쿼리를 모아둠.


@PersistenceContext
EntityManager em; --JEE 관리하는 트랜젝션 참여.
엔티티 생명주기 엔티티 생명주기
비영속 new/transient : 영속성 컨텍스트와 전혀 관계가 없는 상태 , 객체만 생성했고 아직 저장안함.
- Member member = new Member();
영속 managed: 영속성 컨텍스트에 저장된 상태
- em.persist(member);
- em.find()
- jpql 사용 상태
준영속 detached : 영속성 컨텍스트에 저장되었다가 분리된 상태
- em.detach()
- em.close();
- em.clear() ; 영속성 초기화
삭제 removed : 삭제된 상태
- em.remove(member);

영속성 컨텍스트 특징
1. 식별자 존재
2. 보통은 트랜젝션 커밋할때 데이터베이스 반영(flush)
3. 장점: 1차 캐시, 동일성 보장, 트랜잭션을 지원하는 쓰기 지연, 변경감지(update시 dirty checking), 지연로딩

동적 update, insert
@org.hibernate.annotations.DynamicUpdate
@Dynamic Insert
컬럼이 30개 이상될때 정적수정쿼리보다 빠름. 컬럼 많을때 고려.

플러시
영속성 컨텍스트의 변경 내용을 데이터베이스에 "동기화" 하는 작업.
변경감지동작, 영속성 컨텍스트에 있는 모든 엔티티 스냅샷과 비교, 수정된 엔티티를 찾는다. 수정쿼리 SQL 젖아소, 후에 데이터베이스 전송
호출 방법: 직접호출(em.flush()), 트랜잭션 커밋 시 플러시 자동호출, JPQL & Criteria 객체지향 쿼리 실행시 플러시 자동 호출
e.setFlushMode(FlushModeType.AUTO);
FlushModeType.AUTO : 커밋이나 쿼리를 실행할 때 플러시(기본값)
FlushModeType.COMMIT: 커밋할때만 플러시

준영속
영속->준영속
1차 캐시, 지연 SQL 저장소, 변경감지, 지연로딩, 해당 엔티티를 관리하기 위한 모든정보 제거.
식별값 가짐
em.detach()
: 특정 한 엔티티 영속성 컨텍스트 관리하지마!
em.clear();
: 해당 엔티티 영속성 컨텍스트 관리하지마! , 수정해도 DB 영향 없음
em.close()
:개발자가 실제 사용하는경우 드뭄

병합
준영속-> 영속
em.merge(member);
새로운 영속 상태의 엔티티를 반환.
cf) 영속성여부(엔티티관리여부) : em.contains(member)

비영속 병합
해당 엔티티가 없으면 생성해서 병합. 있으면 업데이트.

*context : 맥락, 문맥
엔티티 맵핑 @Entity
테이블과 매핑되는 기본 단위.
- name : jpa에서 사용할 엔티티 이름.
- 기본생성자 필수(public or protected)
- final 클래스, enum, interface, inner 클래스에서 사용불가.
- 저장할 필드에 final 사용하면안된다.

@Table
클래스가 어떤 테이블과 매핑되는지 설정
- name :매핑할 테이블이름
- catalog : catalog 기능있는 데이터베이스에서 매핑
- schema
- uniqueConstraints : DDL 생성시 유니크 제약조건.
uniqueConstraints={@UniqueConstraint(name="NAME_AGE_UNIQUE", columnNames={"NAME", "AGE"})}

@Id

엔티티 식별자
- 직접할당
자바 기본형, 자바 래퍼형, String, java.util.Date, java.sql.Date, java.math.BigDecimal, java.math.BigInteger
- IDENTITY 전략:자동 키생성 : 주로 MySQL,, PostgreSQL, SQL Server, DB2에서 사용.
@GeneratedValue(strategy=GenerationType.IDENTITY)
DB 식별 컬럼 사용해서 식별자 생성:persist() 저장 시점 insert 쿼리 실행, 쓰기지연 동작안함.
spring.jpa.hibernate.use-new-id-generator-mappings =true
- SEQUENCE 전략 : 데이터베이스 시퀀스 사용 : 오라클, PostgreSQL, DB2, H2
@SequenceGenerato(name="review_seq_gen", sequenceName="hotel_review_seq", allocationSize=1)
@GeneratedValue(generator="review_seq_gen")
persist() 저장 시점 시퀀스 추가 쿼리 실행-> 트랜젝션 commit 시 insert
allocationSize 기본값 50 : 시퀀스 전략. 50개를 메모리에 미리 할당받아 호출수를 줄임.
단 두개 이상 jvm 을 사용하면 충돌 우려 allocationSize =1 사용하여 해결.
- TABLE 키생성 테이블 사용 :
@TableGenerator(name="idgen", table="id_gen", pkColumnName="entity", pkColumnValue="city", valueColumnName="nextid", initialValue=0, allocationSize=1)
GenerateValue(generator="idgen")
1. id_gen테이블에서 식별자 구함. 레코드 존재 않을 때 insert 실행, 다음식별자 id_gen 반영
-AUTO전략
@GeneratedValue(strategy=GenerationType.AUTO) 오라클 sequence, mysql identity를 사용
* 자연키 : natural key, : 비즈니스에 의미가 있는 키 ex) 주민번호, 이메일, 전화번호
* 대리키 : surrogate key : 비즈니스와 관련없는 임의로 만들어진 키, 대체키,ex) 오라클 시퀀스, auto_increment, 키생성 테이블 사용.
대리키 권장


@Basic
보통 생략되어 사용, int, long, String과 같은 기본타입, 래퍼타입, BigInteger, BigDecimal, Calendar, Time, Timestamp, enum, 상기의 배열

@Timestamp

java.util.Date 사용시
@Temporal(TemporalType.TIMESTAMP)
java.sql.Timestamp , java.util.Date로 변환
DATE : java.sql.Date
TIME : java.sql.Time
TIMESTAMP : java.sql.Timestamp : Mysql : datetime, H2,오라클, postgreSQL : timestamp
하이버 네이트 5.2 LocalDateTime 사용

@Column
없으면 타입명과 컬럼값 같음
- name
- nullable=false
- length=10
- insertable=false :면 id값 빼고 insert
- updatable=false : 면 update 대상 제외
-table 하나의 엔티티 두개이상 테이블 매핑.
- unique
-columnDefinition
- precision, scale : BigDeciaml 타입에서 사용한다. BingInteger도 사용가능, precision 소숫점포함 전체 자릿수, scale 소수의 자릿수 아주 큰숫자, 정밀 한소수 다루어야 할때 사용.

@Enumerated(EnumType.STRING)
STRING 설정안하면 기본타입으로 저장.
@Lob
필드길이 제한 없음, CLOB: 필드 타입 문자 BLOB : 나머지

@Access(AccessType.PROPERTY) 필드 상단
프로퍼티 접근방식, get, set 메서드 통해서 접근 == @id 를 get 메소드 선언 과 같음
@Access(AccessType.FIELD) get 메서드 상단
필드 접근방식 set 메서드를 사용하지 않음. == @id 를 필드에 선언 과 같음
* 필드에 id 를 선언하고 메서드에 @Access 프로퍼티 선언 하면 동시사용 가능.

@transient
transient private long timestamp = System.currentTimeMillis();
사전 일시적인, 트랜션트
영속대상 제외

기본생성자
필수, public or protected

final class 불가.
프록시 객체를 생성 부락.

Serializable 인터페이스
캐시 구현기술 사용시. 필요

exclude-unlisted-classes true 시 자동추가 비활성화

cf) 필드에서만 쓸수있는게 아니라 get 메소드에 선언가능
트랜젝션 ACID : Atomic 원자성, Consistency 일관성, Isolation 격리성, Durability 지속성
Read Uncommited   커밋되지 않는 읽기 : 커밋안된 데이터  다른트렌젝션 update, insert, delete 읽기
                                Dirty reads :  Rollback 시 정합성 깨짐
Read Commited       커밋된 읽기 :  다른 트랜젝션  update insert delete 읽기
                                Non-Repeatable read :  업데이트 영향으로 첫번째 조회 값과 두번째 조회값 다름
Repeatable Read     반복 읽기 : 다른 트랜젝션 insert, delete 읽기
                                 Phantom read :  insert, delete 영향으로 첫번째 조회 값과 두번째 조회가 있다없음
Serilization                직렬화 : 락을 걸어 트랜잭션 이용하는 부분 사용 못함. 병렬성 저하. 


JPA 낙관적 락 : 트랜잭션 충돌이 거의 발생하지 않는다. 커밋 되는 시점에 충돌여부 알수있다. 
LockModeType.NONE : 커밋시 version정보 update 쿼리로 : 두번의 갱신문제 해결
                                    > 조회 ~ 수정 트랜잭션 격리
LockModeType.Optimistic:  커밋시 version 정보를 select 쿼리로 보냄:   dirty read, Non-Repeatable Read 해결                    +스칼라 타입 으로 조회 시 소프트락 적용안됨 ?? 스칼라타입: 단하나, <->컴포지트
Optimistic.Force_increment : 커밋시 version 정보를 update  쿼리로 : 연관관계 엔티티 함께 버전 관리

JPA 비관적 락 : 타임아웃. 
PESSIMISTIC_WRITE
PESSIMISTIC_FORCE_INCREMENT

출처 : https://ojt90902.tistory.com/723

RESOURCE_LOCAL

: 변경내용 영속 컨텍스트에 보관, 트랜잭션을 커밋하는 시점에서 영속 컨텍스트로 추적한 변경을 DB에 반영.

JTA 트랜잭션 타입.
Java Transzction API
UserTransaction utx = (UserTransaction)new InitaialContext().lookup("java:comp/UserTransaction");
utx.begin();
EntityManager em = emf.createEntityManager();
em.joinTransaction; (이부분은 필히 작성안해도됨. )

utx.commit()
utx.rollback()
@JoinTable 조인테이블 = 연결 테이블 = 링크 테이블 
다대다 관계 설정. 
cf) 연관관계 설정 - @JoinColumn or JoinTable

일대일, 일대다, 다대일, 다대다

벨류 객체 한개의 값, 다른 벨류 객체와 구분하기 위한 식별자를 갖지 않는다.
자신만의 라이프 사이클을 갖지 않는다. 자신이 속한 객체가 생성될 때 함께 생성/삭제시 삭제

생성시 모든 프로퍼티를 파라미터로 전달받는다.
읽기전용 프로퍼티만 제공한다.
equals() 메서드를 재정의 한다.
각 프로퍼티의 값을 이용, 해시코드를 생성하도록 hashCode()메서드를 재정의 한다.

public class ValueObject{
private String a;
private String b;
private String c;

public ValueObject(String a, String b, String c){
this.a = a;
this.b = b;
this.c = c;
}

public String getA(){return a;}
public String getB(){return b;}
public String getC(){return c;}

@Override
public boolean equals(Object o){
if(this==o) return true;
if(o==null || getClass() !=o.getClass()) return false;
ValueObject vo = (ValueObject)o;
return Objects.equals(a, vo.a) && Objects.equals(b, vo.b) & Objects.equals(c, vo.c);
}

@Override
public int hashCode(){
return Objects.hash(a,b,c);
}
}
@Embeddable
@Embedded
@AttributeOverrides
@secondaryTable
@Embeddable
public class ValueObject{
}

@Entity
public class UsingObject{

@Id
private String id;

@Embedded
privae valueObject;
}

매핑 대상이 되도록 설정. update 시 트랜젝션 내에서 변경되면 변경내역 DB 반영

@Embedded
@AttributeOverrides({
@AttributeOverride(name..., column=@Column(name="valueObject")), @AttributeOverride ...})
private Address valueObject2;

동일 테이블 사용하는 밸류클래스 이름 재정의 사용

@Entity
@SecondaryTable(
name="sight_detail",
pkJoinColumns=@PrimaryKeyJoinColumn(name="sight_id",refferencedColumnName="id" )
)
public class Sight{

@Embeded
@AttributeOverrides({
@AttributeOverride
})
private SightDetail detail;
}

복합키 사용 벨류테이블
1. equals()메서드, hashCode() 메서드 재정의
2. Serializable 인터페이스 상속.
(3. 생성자. null 이면 IllegalArgumentException. )
@Entity
@public class MonthChage{
@Id
privateMonChageId id;
}
@Embeddable
public classMonChagedId implements Serializable{
@Column

}

 

방향 & 다중성 & 연관관계 주인
설명  방향 :direction : 단방향, 양방향
다중성 :multiplicity: 다대일(@ManyToOne), 일대다(@OneToMany), 일대일(@OneToOne), 다대다(@ManyToMany)
연관관계 주인 :owner: 양방향 연관관계의 주인

@JoinColumn
name : 매핑할 외래 키 이름
referencedColumnName :외래키 참조하는 대상 테이블 컬럼명
foreignKey : 외래키 제약조건. 테이블 생성시만 사용
그외 columne 속성과 같음

@ManyToOne : 다대일 관계 사용
optional : false : 항상 연관된 테이블 있음.
fetch : 글로벌 패치 전략 @ManyToONe = FetchType.EAGER, @OneToMany=FetchType.LAZY
cascade : 영속성 전의 기능
targetEntity : 연관된 엔티티 타입 정보 설정, 거의 사용안함.
@OneToMany
private List members;
@OneToMany(targetEntity=Member.class)
private List members;


단방향
회원 - 팀.
객체 그래프 탐색 : 참조를 통해서 연관관계를 탐색.  ex) member.getTeam()
저장 , 수정
em.persist(team1)
member1.setTeam(team1)
em.persist(member1)
조회
member.getTeam()  : 객체 그래프 탐색
삭제
Member member1 = em.find(Member.class, "member1");
member1.setTeam(null);  ///1. 연관관계  모두 제거.
em.remove(team)               ///2. 해당 엔티티 삭제

양방향
연관관계의 주인은 테이블에 외래키가 있는곳.
** 양방향 연관관계의 주의점 : 객체 관점에서 양쪽방향에 모두 값을 입력해주는 것이 가장 안전.
** 무한루프 주의 toString 시 member, team 에서 서로 호출. Lombok 사용시 필히.
em.persist(team1)
member1.setTeam(team1)                     // 객체 , 실제 데이터 저장
team1.getMembers().add(member1)  //객체 정보 저장
em.persiste(member1)
+)
public void setTeam(Team team){
  if(this.team !=null) this.team.getMembers().remove(this);
  this.team = team;
  team.getMembers().add(this);
}
조회
List<Member> members = team.getMembers();


cf)
JPQL
단방향 연관관계 : 다대 일
String jpql = "select m from Member m join m.team t where t.name=:teamName";
List resultList = em.createQuery(jpql, Member.class).setParameter("teamName", "팀1").getResultList();
다중성 DB ERD 객체 단방향 객체 양방향
다대일
@ManyToOne
연관관계맵핑 @ManyToOne
@JoinColumn(name="TEAM_ID")
privae Team team;   //cf) 0..1   : zero to one 0~1맵핑
@OneToMany(mappedBy = "team")
private List<Member> memers;
//cf) Collection, List, Set, Map 가능
일대다
@OneToMany
연관관계맵핑 @OneToMany
@JoinColumn(name="TEAM_ID")
private List<Member> members;
@ManyToOne
@JoinColumn(name="TEAM_ID", insertable=false, updatable=false)
private Team team; //읽기전용
일대일
@OneToOne
연관관계맵핑 @OneToOne
@JoinColumn(name="TEAM_ID")
private Team team;
@OneToOne(mappedBy = "member")
private Member member;
다대다
@ManyToMany
 
연관관계맵핑 @ManyToMany
@JoinTable(name="Member_has_TEAM"
    , joinColumns = @JoinColumn(name="MEMBER_ID")
   , inverseJoinColumns = @JoinColumn(name="TEAM_ID"))
private List<Team> teams;
@ManyToMany(mappedBy ="team")
private List<Member> members;

다대다: 매핑 한계 ; 연결 엔티티 사용
연관관계맵핑 @Entity
@IdClass(MemberTeam.class)
public class MemberTeam{

  @id
  @ManyToOne
  @JoinColumn(name="MEMBER_ID")
  private Member member;

  @id
  @ManyToOne
  @JoinColumn(name="TEAM_ID")
  private Team team;

  private String desc;
}
public class MemberTeamId impliments Serializable{

  private int member;
  private int product;

  //hashCode, equals 수정.

  // 기본생성자
}


@OneToMany(mappedBy = "member")
private List<MemberTeam> memberTeam;
다대다: 새로운 기본키 사용    
  @Entity
@IdClass(MemberTeam.class)
public class MemberTeam{

  @id
  @GeneratedValue
  private Long id;

  @ManyToOne
  @JoinColumn(name="MEMBER_ID")
  private Member member;

  @ManyToOne
  @JoinColumn(name="TEAM_ID")
  private Team team;

  private String desc;
}
@OneToMany(mappedBy="member")
private List<MemberTeam> membersTeams ;



* 0..1  : zero to one : 0~1개 맵핑

고급매핑- 상속관계 매핑 : 슈퍼타입, 서브타입 논리모델
- 조인전략
@Inheritance(strategy=InheritanceType.JOIND)
- 각각의 테이블로 변환, 타입컨럼 추가. 

@Entity
@Inheritance(strategy=InheritanceType.JOIND)
@DiscriminatorColumn(name="DTYPE")
public abstract class Item{
  @Id @GeneratedValue
  @Column(name="ITEM_ID")
  private Long id;
  //생략
}

@Entity
@DiscriminatorValue("A")
public class Album extends Item{
  //생략
}

// 기본키 컬럼 재정의
@Entity
@DiscriminatorValue("B")
@PrimaryKeyJoinColumn(name="BOOK_ID")  //ID 재정의
public class Book extends Item{
  //생략
}

장점: 테이블이 정규화, 외래키 참조 무결성 제약조건활용, 저장공간 효율적
단점 : 조회 할때 조인 많이 사용 성능저하, 조회 쿼리 복잡, 등록시 insert 두번실행. 

cf ) 구현클래스마다 테이블 전략(@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS))
- DB , ORM 양쪽 시선으로도 비효율적. 
 
- 단일 테이블 전략
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
조인이 없어 빠르고 단순하지만, 자식엔티티가 매핑한 컨럼은 모두 null 허용.  테이블이 커지면서 저하 우려. 
구분컬럼  지정하지 않으면 기본으로 엔티티이름 사용. 

@Entity() 
@Table(name="LINK") 
@Inheritance(strategy = InheritanceType.SINGLE_TABLE) 
@DiscriminatorColumn(name="LINK_TYPE", length = 1) 
public class AbstractLinkModel extends BaseEntity{
 생략
@Entity 
@DiscriminatorValue("B") 
public class LinkBookModel extends AbstractLinkModel { 
- 구현클래스마다 테이블 전략

@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
일반적으로 비추천. 구분컬럼 미사용, 티에블 통합 쿼리 어려움.  orm db 양쪽에서 모두 비추 
@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
public abstract class Item{
하기 동일. 
테이블 상관없이 특정정보 자식에게 상속
@MappedSuperclass
공통사용 매핑정보 모아줌 - ex) 등록일자, 수정일자, 등록자, 수정자. 
@MappedSuperclass

public abstract class Item{
@IdClass

@IdClass  : 데이터베이스에 가까움
@Entity
@IdClass(PId.class)
public class Parent{
  @Id
  @Column(name="P_ID1")
  privae String id1;

  @Id
  @Column(name="P_ID2")
  privae String id2;

// 생략
}

public class PId implements Serializable{
  private String id1;
  private String id2;
  public PId(){} 
  public ParentId(String id1, String id2){this.id1=id1; this.id2=id2;}
  @Override
  public boolean equals(Object o){...}
  @Override
  public int hashCode(){...}
}
@EmbeddedId @Entity
public class Parent{
  
  @EmbeddedId
  private PId id;

// 생략
}

@Embeddable
public class PId implements Serializable{
  @Column(name="P_ID1")
  private String id1;
 @Column(name="P_ID2")
  private String id2;
  public PId(){} 
  public ParentId(String id1, String id2){this.id1=id1; this.id2=id2;}
  @Override
  public boolean equals(Object o){...}
  @Override
  public int hashCode(){...}
}

** equeals, hashCode  구현 안하면 예상과 다른엔티티 조회되거나 엔티티를 찾을수없어짐. 
복합키는 @GenerateValue 불가.  
식별 비식별 * 식별관계 : Identifying Relationship : 받아온 식별자를 기본키 +외래키로 사용
* 비식별관계 : Non-Identifyng Relationship : 받아온 식별자는 외래키로만 사용, 새로운 식별자 추가.  Null 허용시 선택적 비식별(Optional) , 허용안하면  필수적 비식별(Mandatory)

** equeals, hashCode  구현 안하면 예상과 다른엔티티 조회되거나 엔티티를 찾을수없어짐.
비식별 고나계를 사용하고 long 타입 대리키 사용하는것 추천. 
@IdClass
(비식별)
 데이터베이스에 가까움
@Entity
@IdClass(PId.class)
public class Parent{
  @Id
  @Column(name="P_ID1")
  privae String id1;
  @Id
  @Column(name="P_ID2")
  privae String id2;

// 생략
}

public class PId implements Serializable{
  private String id1;
  private String id2;
  public PId(){} 
  public ParentId(String id1, String id2){this.id1=id1; this.id2=id2;}
  @Override
  public boolean equals(Object o){...}
  @Override
  public int hashCode(){...}
}
@EmbeddedId
(비식별)
객체지향적, JPQL 작성시 불리할수있다. 

@Entity

public class Parent{
  
  @EmbeddedId
  private PId id;

// 생략
}

@Embeddable
public class PId implements Serializable{
  @Column(name="P_ID1")
  private String id1;
 @Column(name="P_ID2")
  private String id2;
  public PId(){} 
  public ParentId(String id1, String id2){this.id1=id1; this.id2=id2;}
  @Override
  public boolean equals(Object o){...}
  @Override
  public int hashCode(){...}
}

복합키는 @GenerateValue 사용불가
@IdClass
(식별)
@Entity
public class Parent{
  @Id
  @Column(name="P_ID")
  privae String id;
// 생략
}

public class ChidId impliments Serializable{
  private String parent; 
  private String childId;

  //equals, hashcode
}


@Entity
@IdClass(ChildId.class)
public class Child{
  @Id
  @ManyToOne
  @JoinColumn(name="P_ID")
  privae Parent parent;

  @Id @Column(name="CHILD_ID")
  private String childId;
// 생략
}
@EmbeddedId
(비식별)
@Entity
public class Parent{
  @Id
  @Column(name="P_ID")
  privae String id;
// 생략
}

@Embeddable
public class ChidId impliments Serializable{
  private String parentId;
  @Column(name="CHILD_ID")
  private String id;

  //equals, hashcode
}


@Entity
public class Child{
  @EmbeddedId
  private ChildId id;

  @MapsId("parentId")
  @ManyToOne
  @JoinColumn(name="P_ID")
  public Parent parent;
// 생략
}
일대일 식별 @Entity
public class Board{
  @Id @GeneratedValue
  @Column(name="BOARD_ID")
  private Long id;

  @OneToONe (mappedBy ="board")
  private BoardDetail boardDetail;
}

@Entity
public class BoardDetail{
  @ID
  private Long boardId;
 
  @MapsId
  @OneToONe
  @JOinColumn(name="BOARD_ID")
  private Board board
}

 

프록시와 연관관계  
em.getReference( 실제 사용 하는 시점(targer.getName() , member.getOrders().get(0))까지 데이터베이스 조회 미룸.  접근을 위임한 프록시 객체 반환. 이미 엔티티가 있으면 엔티티 반환. 
- 준영속시 에러 발생   LazyInitializationException
- 연관관계 설정시 데이터 베이스 접근횟수 줄임. 
- PersistenceUnitUtil.isLoaded(entity); 프록시 인지 엔티티인지 확인. 
즉시로딩 vs 지연로딩 즉시로딩 :EAGER: @ManyToOne(fetch=FetchType.EAGER)
지연로딩 :LAZY: @ManyToOne(fetch=FetchType.LAZY)

기본설정값
@ManyToOne, @OneToOne:  즉시로딩 EAGER
optional=false : 내부조인
optional=true : 외부조인
@OneToMany, @ManyToMany :  지연로딩. LAZY
optional=fals: 외부조인
optional=true : 내부조인 

추천은 모두 지연로딩 사용후 완료단계에서 즉시로딩으로 최적화 
컬랙션이 많을경우 즉시로딩 미권장. 
즉시로딩은 항상 외부조인 사용. 
CASECADE  
   
   



hash code
threadLocal

 

 

728x90

참고서적 :

DBMS 아키텍처 부분 : DB 성능 최적화를 위한  SQL 실전가이드 SQL 레벨업 미크 지음, 윤인성 옮김 

DBMS 기본 : 김상형의 SQL 정복

 

SQL 관련 커뮤니티 : http://www.gurubee.net/

 

꿈꾸는 개발자, DBA 커뮤니티 구루비

꿈꾸는 개발자, DBA 커뮤니티 구루비

www.gurubee.net

 

http://www.yes24.com/Product/Goods/22744867

 

SQL 첫걸음 - YES24

왕초보를 위한 정말 쉬운 SQL 입문서를 만나보자!본격적인 빅데이터 시대에 접어들면서 기존 대비 더 효율적이고 폭넓은 데이터 분석을 위한 수요가 커질 것으로 기대되는 가운데, SQL 활용 범위

www.yes24.com

 

 

SQL 기초
데이터 컴퓨터 안에 기록되어 있는 숫자. 
데이터베이스 데이터의 집합, 컴퓨터 안에 기록된 모든것
- 계층형 데이터 베이스  ;  역사가 오래된 DBMS ex) 파일 시스템 , 현재 DBMS로 채택되는 경우는 많지 않음. 
- 관계형 데이터 베이스 : 관계대수라는 것에 착안하여 고안한 데이터 베이스. 
- 객체지향 데이터 베이스 : JAVA, C++  가능하면 객체 그대로를 데이터베이스의 데이터로 저장하는것. 
- XML 데이터베이스 :  XMl 형식으로 데이터 저장, XQuery라는 전용 명령어 사용. 
- 키-밸류 스토어 KVS :  NoSQL 이라는 슬로건으로부터 생겨난 데이터 베이스. 열지향 데이터베이스.
                                     ex) 연상배열(=결합성배열 =맵= 딕셔너리),  해시 테이블. 
DBMS Database Managemet System
생산성, 기능성, 신뢰성
SQL  IBM 개발한 SEQUEL 관계형 데이터베이스 조작용 언어를 기반으로 만들어짐. 

DML : Data Manipulation Language 데이터 추가, 삭제, 갱신
DDL : Data Definition Language  데이터 정의, 데이터베이스 객체를 만들거나 삭제
DCL : Data Control Language : 트랜젝션 제어어 외 
데이터베이스 제품 Oracle
DB2 : IBM
SQL SERVER
PostgreSQL
MySQL
SQLite

SQL 방언존재
데이터베이스 서버 클라이언트/서버모델. 
테이블 구조 DESC 테이블명;   
자료형
INTEGER 형
CHAR 형
VARCHAR형   * 고정과 가변형
DATE형
TIME 형

검색조건 select
where  "=" "<>"
문자열상수 리터럴 : 자료형에 맞게 표기된 상수값.  ex) 'ABC'
ISNULL
비교연산자

AND, OR, NOT  : OR 보다 AND 가 우선순위가 높음. 
LIKE   :
메타문자
'%', : 문자가 없거나 하나 이상의 어떤값이 와도 됨.
'_'   : 하나의 문자에  어떤값이 와도 됨. 
'\' : 이스캐이프 처리. 
'''' : 이스케이프 처리.    " ' " 문자는 2개 연속기술.   

Order by  : Null 은 가장 작은 값 취급 , order by price* quantity desc  << 연산가능. 
desc
asc        : Order by a asc, b desc;
limit   행수  offset 시작행   ex)  limit 3 offset2  앞에 2행 제외하고 3개 
rownum

조회 순서
FROM > ON > JOIN > WHERE > GROUP BY > HAVING > SELECT
수치연산 + - * / % MOD

연산순서
* / % > + -
별명 Alias AS '별명'  : ASCII 문자 이외의 것. 
AS "별명"
Null null +1 , 1+null, 2*null, 1/null   .>> 모두 null 
함수  MOD(10,3)  -> 1
round
truncate

문자열연산 'ABC' || '1234' => 'ABC1234'  
+ : SQL Server
|| : Oracle, DB2, PostgreSQL
CONCAT : Mysql 

Substring
Trim

문자세트 ex) EUC-KR or UTF-8
EUC-KR ASCII 문자1바이트, 한글 2바이트 
UTF-8 ASCII 문자 1바이트 한글 3바이트. 
날짜 연산 SELECT CURRENT_TIMESTAMP;
TO_DATE('2014/01/25', 'YYYY/MM/DD')
SELECT CURRENT_DATE + INTERVAL 1 DAY;
CASE CASE WHEN 조건1 THEN 식1
           [WHEN 조건2 THEN 식2]
           [else 식 3]                              // 생략시 null   처리 주의 
END
           
CASE WHERE 조건1 THEN 값1
           [WHEN 조건2 THEN 값2]
           [else 값3 ]
END

decode (Oracle)

null 체크
NVL (Oracle)
isnull(SQL server)
COALESCE  : 표준SQL
DML insert into 테이블(열...) values( 값...);
null, default
delete from 테이블명 where 조건식. 
update 테이블명 set 열=값  ... where 조건식   ... Oracle은 set순서 상관없고 mysql은 영향있음. 

물리 삭제 : 실제 삭제
논리 삭제 : 삭제 플래그
집계함수 count, sum, avg, min, max,

distinct count(*) 불가. : count 가 먼저 계산됨.  count(distinct name)


WHERE > GROUP BY > HAVING >SELECT > ORDER by
Having : 검색한뒤 그룹화 
cf) having count(name)=1   200쪽부터 보기
   
   

 

DBMS 아키텍처

1. SQL 구문입력  웹 or 애플리케이션 or SQL 인터페이스 -> SQL 구문
2. 상호연계
   (RDBMS)
1. 쿼리 평가엔진 플랜 실행 기능, 파서, 연산평가 기능, 옵티마이저 SQL 구문 분석, 실행계획(어떤순서 기억장치 데이터 접근 결정)
2. 접근 메서드 ->트랜젝션메니저
┿>리커버리 메니저
실행계획에 기반을 둬서 데이터에 접근
3. 버퍼 메니저 ->락메니저 버퍼 용도로 사용하는 메모리 영역 디스크 용량 매니저와 연동작동
4. 디스크 용량 매니저 동시 실행제어 어떻게 데이터를 저장할것인가
  트랜젝션 메니저      각각의 처리 트랜젝션으로 관리
  락메니저     대기시킴
  리커버리 매니저     장애를 대비해 백업, 복구를 수행
3.참조 인덱스파일 -> 데이터 파일  : 시스템 카탈로그  

Trade-off  어느것을 얻으려면 반드시 다른 것을 희생하여야 하는 경제 관계

Query : 질의 좁은의미 select 구문

DBMS 와 버퍼        
기억 장치의 계층 1차 기억장치 
- 레지스트 메모리
2차 기억장치
-HDD, CD, DVD, 플레시메모리
3차 기억장치
테이프
1차일수록 비쌈, 고가, 접근속도 빠름
DBMS 기억장치 하드디스크, 메모리, 버퍼를 활용한 속도 향상
버퍼, 캐시 : 성능향상을 목적으로 데이터 저장 메모리
 cf) 매우 적은 양의 데이터에만 접근하는 SQL 구문은 저장소 I/O  보다 CPU 연산에 많은시간을씀
데이터 캐시 초기값 128MB 버퍼캐시(ORACLE), 버퍼풀(Mysql)
초깃값: 128MB(Mysql)
SELECT 구문에서 버퍼에서 데이터 있으면 그것 사용. 
로그 버퍼 초기값 64KB innodb_log_buffer_size 16777216
초깃값: 8MB(Mysql)
갱신처리(commit)시 로그버퍼에 변경정보 보내고 디스크 변경 >> 성능 보완, 메모리 휘발성 보안
로그        
         

buffer 완충제, 

 

 

RDBMS 레코드
필드
테이블
인덱스

프로시저
함수
제약사항
로, 행, 튜플
컬럼, 열, 어트리뷰트 
릴레이션
키-필드만 갖고 있는 테이블에 대한 동작속도 높여주는 자료구조
여러 테이블, 뷰의 데이터를 조합하여 만듬,  테이블 아닌 테이블처럼 보여줌
프로세스를 절차적으로 기술 CREATE OR REPLACE PROCEDURE
특정 계산 수행, 반드시 리턴값 하나 존재,  CREATE OR REPLACE FUNCTION
무결성 보장하기 위한 데이터베이스 객체중하나. 
무결성 제약조건 데이터 정확성,
일관성
일관성, 정확성 보장위해 저장, 삭제, 수정등을 제약하기 위한 조건. 
개체 무결성 : 기본키는 null, 중복값 불가
참조 무결성 : null 이거나 참조하는 릴레이션 기본키와 동일
도메인 무결성 : 속성값은 정의된 도메인값 ex) 남, 여 만 넣을수있는 조건
고유 무결성: 고유값 조건이 주어지면 같은값 없어야
Null무결성 : not null 조건
키 무결성 : 최소 테이블당 한개 이상의 키 
쿼리문 종류 DDL
DML
DCL
TCL
데이터 정의 어, DB 오브젝트 생성, 삭제 변경 ex) create
데이터 조작 어, DB 조회, 삽입, 삭제, 변경 ex)select
데이터 제어 어, 사용자 권한 관리 ex) grant
트랜젝션 제어어 ex) commit, rollback..
명명규칙 DB
키워드
책마다 기준이 달라서 추후 정리
https://docs.actian.com/ingres/11.0/index.html#page/CharQueryRepUser/Recognition_of_Delimited_Identifiers.htm
타입 INT
DECIMAL
CHAR
VARCHAR
DATE
정수
실수
고정길이 문자열
가변길이 문자열
날짜
CHAR(10) VS VARCHAR(10) abc 작성시 char 는 10바이트를 다쓰고 varchar는 7바이트를 사용. 
단 정확히 10자인 데이터를 저장할 때는 char 가 유리. 
char는 길이기 일정해 속도가 빠르다. 
Number vs int vs uint number
int
uint


64비트, NaN, 소수점까지 표현 oracle 은 int를 number로 선언사용
32비트 정수
unsigned int , 양수만 표현
https://docs.oracle.com/database/121/SQLRF/sql_elements001.htm#SQLRF0021
SQL 실행순서 From > (join 조건)ON > JOIN >  WHERE >  GROUP BY > HAVING > SELECT 
Having 그룹화 이후 데이터 추출조건
집계함수 sum
avg
min
max
stddev / stdev(ms)
variance
총합
평균
최소값
최댓값
표준편차
분산
truncate table 이름   테이블 전체 비울때 
서브쿼리 연산자 ANY(서브쿼리)
ALL(서브쿼리)
exists(서브쿼리)
하나만 참이어도 
모두 참일때
결과가 있는지만 확인
연관서브쿼리 필드, (서브쿼리) select name , (select id from classA where classA.id = student.id) from student
인라인뷰 from (서브쿼리)  
테이블 뷰 UNION
Intersect
minus
합집합
교집합
차집합
함수 스칼라 함수
집계함수
시스템함수
문자열함수
수학함수
sum, avg, count
널 관련 처리, 타입변환
문자길이, substring, 케이스 변환 
CTE
WITH ()
Common Table Expressions 쿼리 실행중에 메모리에 존재하는 테이블 
with 테이블명(필드명들) as()
over   집계함수 보조. 
select name, sum(salary) over() as 월급총합 from employee;
rank()   select rank() over(order by salary desc), * from  employee
통계 관련 ntile
lag
lead
percentile
pivot
 
     
     

 

   ORACLE SQLServer Mysql
데이터베이스보기 SELECT NAME FROM v$database; SELECT name FROM master.sys.databases show databases;
페이징 관련 의사컬럼(Pseudo column)
: 인위적추가된 컬럼 
ex)rownum, rowid
top, limit  
offset fetch order by 필드 offset 건너뛸 행수 rows fetch next 출력할 행수 rows only 
order by 생략가능
offset 0 rows 생략가능
order by 반드시
offset 0 rows 반드시
limit 가 유사기능
시퀀스 CREATE SEQUENCE emp_seq
       INCREMENT BY 1
       START WITH 1
       MINVALUE 1
       MAXVALUE 9999
       NOCYCLE
       NOCACHE
       NOORDER;
CREATE SEQUENCE Schema.SequenceName AS int START WITH 1 INCREMENT BY 1 ;  
GENERATED [ ALWAYS | BY DEFAULT [ ON NULL ] ]
AS IDENTITY [ ( identity_options ) ]

ex)
CREATE TABLE STUDENT(
no INT GENERATED AS IDENTITY ​PRIMARY KEY
);​

Number 타입
BigInt CREATE TABLE student(
no INT NOT NULL AUTO_INCREMENT PRIMARY KEY
);
숫자 Number

Number(최대자리수, 소수점이하정밀도)

Number(5, -3) 천의자리 반올림

Decimal or Numeric
날짜 SYSDATE

select sysdate + 12 from dual;
GETDATE() NOW()

 

728x90

출처 : 소스관리 예제로 쉽게 배우는 MySQL 5.x by 정진용

정보 시스템이나 개인이나 단체의 요구를 처리하는데 있어서 중요하다고 인식되는 모든 지식
데이터 지구상에 존재하는 모든 개체들의 개념, 사상, 명령 등을 표현한 것으로 인간 또는 기계가 감지할 수 있도록 숫자, 문자, 기호 등을 이용하여 형식화한 것. 
데이터베이스 데이터베이스
바크만 : 어느 한 조직의 여러 응용 시스템들이 공용할 수 있도록 통합, 저장된 운영 데이터의 집합
C.J.Date : 데이터 베이스는 특별한 기업의 응용 시스템에서 사용하기 위해서 저장된 집합
DBMS
R.Elmasri :  DBMS는 사용자에게 데이터베이슬르 생성하고 유지할 수 있게 해주는 프로그램 집합
데이터베이스 조건 4가지 1. 통합된 데이터(Integrated data) : 동일데이터 중복 안되있음. 
완전히 배제된것이 아니고 최소한의 중복, 통제된 중복을 허용
2. 저장 데이터(Stored data) : 컴퓨터가 접근 가능한 자기테이프와 같이 저장 매체에 저장된 데이터
3. 운영데이터(Operational data) : 어떤 한 조직의 고유 기능을 수행하기 위해 반드시 필요한 데이터
4. 공용데이터(Shared data) :  어느 한 조직의 여러 응용프로그랩들이 공동으로 소유하고 유지하며 이용하는 데이터
데이터베이스 특성 1. 실시간 접근성(Real-time accessibility)
2. 계속적인 변화(Continuous evolution)
3. 동시공유(Concurrent sharing)
4. 내용에 의한 참조(Content reference) : 레코드 위치, 주소가 아닌 사용자 요구 데이터값에 의해 참조
모델 1. 계층 데이터모델(Hierachical Data Model)

   
   
   
주요용어 개체(entity)
애트리뷰트(attribute)
도메인(domain) : 한 속성이 취할 수 있는 모든 값 총칭

   

 

728x90

esperTech

에스퍼 https://www.espertech.com/
실시간 적재 핵심기술.  룰엔진 라이브러리 
에스퍼만의 쿼리를 사용. 
ex) 과속로직/룰 을 디파인함. 
라이센스 GNU GPLv2 : https://www.jopenbusiness.com/mediawiki/Esper
유사프로젝트 Drools
주요
구성요소
Event 실시간 스트림으로 발생하는 데이터들의 특정 흐름 또는 패턴을 정의
EPL 유사 SQL을 기반으로 하는 이벤트 데이터 처리 스크립트 언어 ex) 과속의 룰 정의 
Input Adapter 소스로부터 전송되는 데이터를 처리하기 위한 어댑터 제공
CSV, Socker, JDBC, Http, 등
Output Adapter 타깃으로 전송하는 데이터를 처리하기 위한 어댑터 제공
HDFS, CSV, Socket, Email, Http, 등
Window 실시간 스트림 데이터로부터 특정 시간 또는 개수를 설정한 이벤트들을 메모리상에 등록한 후 EPL을 통해 결과를 추출. 
아키텍처








에스퍼 EPL
EPL 은 자주 변경됨 >>> 에스퍼 아키텍쳐 확장. 
활용방안 운행자 운행로그 400kb/1초
-> 플럼-> 카프카 -> 스톰
스톰 : spout -> Bolt(에스퍼엔진(Event Processing Language, Core Library)) -> Bolt
                                                                                                 -> Bolt -> 레디스
>> 운전자 운행로그 필터링
>> 과속 운행정보 이벤트 감지
카프카 스파우트
-> 에스퍼 볼트 
-> 레디스 볼트 
-> 레디스 캐시

public class EsperBolt extends BaseBasicBolt{
    private static final long serialVersionUID = 1L;
    private EPServiceProvider espService;      
    #esp 이벤트 스트립 프로세싱 = 에스퍼 서비스 런타임객체 
    private boolean isOverSpeedEvent = false;

    public void prepare(Map stormConf, TopologyContext context) {

        Configuration configuration = new Configuration();
        configuration.addEventType("DriverCarInfoBean", DriverCarInfoBean.class.getName());

        espService = EPServiceProviderManager.getDefaultProvider(configuration);
        espService.initialize();

        int avgOverSpeed = 80;
        int windowTime  = 30;

        String overSpeedEpl =  "SELECT date, carNumber, speedPedal, breakPedal, "
        + "steerAngle, directLight, speed , areaNumber "
        + " FROM DriverCarInfoBean.win:time_batch("+windowTime+" sec) "
        + " GROUP BY carNumber HAVING AVG(speed) > " + avgOverSpeed;

        EPStatement driverCarinfoStmt = espService.getEPAdministrator().createEPL(overSpeedEpl);

        driverCarinfoStmt.addListener((UpdateListener) new OverSpeedEventListener());
    }

    public void execute(Tuple tuple, BasicOutputCollector collector) {

        // TODO Auto-generated method stub
        String tValue = tuple.getString(0); 

        //발생일시(14자리), 차량번호, 가속페달, 브레이크페달, 운전대회적각, 방향지시등, 주행속도, 뮤직번호
        String[] receiveData = tValue.split("\\,");

        DriverCarInfoBean driverCarInfoBean =new DriverCarInfoBean();

        driverCarInfoBean.setDate(receiveData[0]);
        driverCarInfoBean.setCarNumber(receiveData[1]);
        driverCarInfoBean.setSpeedPedal(receiveData[2]);
        driverCarInfoBean.setBreakPedal(receiveData[3]);
        driverCarInfoBean.setSteerAngle(receiveData[4]);
        driverCarInfoBean.setDirectLight(receiveData[5]);
        driverCarInfoBean.setSpeed(Integer.parseInt(receiveData[6]));
        driverCarInfoBean.setAreaNumber(receiveData[7]);

        espService.getEPRuntime().sendEvent(driverCarInfoBean); 

        if(isOverSpeedEvent) {
        //발생일시(14자리), 차량번호
        collector.emit(new Values( driverCarInfoBean.getDate().substring(0,8), 
        driverCarInfoBean.getCarNumber()+"-"+driverCarInfoBean.getDate()));
        isOverSpeedEvent = false;
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        // TODO Auto-generated method stub
        declarer.declare(new Fields("date", "car_number"));
    }

    private class OverSpeedEventListener implements UpdateListener
    {
        @Override
        public void update(EventBean[] newEvents, EventBean[] oldEvents) {
            if (newEvents != null) {
            try {
                isOverSpeedEvent = true;
            } catch (Exception e) {
                System.out.println("Failed to Listener Update" + e);
            } 
         }
     }
}

}
   
   
   

 

728x90

STORM http://storm.apache.org/
대규모 메시지성 데이터 발생
-> 카프카(토픽: 버퍼링 _브로커 한계 전에 이동필요)
-> 스톰(카프카 컨슈머 역할) 1. 분산병렬위치, 영구저장소에 빠른 적재 2. 전처리, 집계, 분석
-> HDFS or NoSQL or RDBMS or Radis(캐시)
라이센스 Apache
유사프로젝트 Samza, S4, Akka, Spark Stram (마이크로배치: 배치처리짧게한것 요즘대세,  스톰은 리얼타임)
주요
구성요소
Spout (이번엔. 카프카 spout)
외부로부터 데이터를 유입받아 가공, 처리해서 튜플을 생성, 이휴 해당 튜플을 Bolt에 전송
Bolt 튜플을 받아 실제 분산 작업을 수행하며, 필터링(Filtering), 집계(Aggregation),조인(Join), 등의 연산 병렬로 실행. 
Topology Spout-Bolt의 데이터 처리 흐름을 정의, 하나의 Spout와 다수의Bolt로 구성. 
Nimbus Topology를 Supervisor에 배포하고 작업을 할당, Supervisor를 모니터링하다 필요시 페일오버(Fail-Over)처리. 
Supervisor Topology를 실행할 Worker를 구동시키며 Topology를 Worker에 할당 및관리. 
Worker Supervisor 상에서 실행중인 자바 프로세스로 spout와 Bolt를 실행
Executor Worker 내에서 실행되는 자바 쓰레드
Task Spout및 Bolt 객체가 할당. 
아키텍처

활용방안 운전자 운행로그 400kb/1초
-> 플럼-> 카프카 -> 스톰
스톰: ->spout->bolt-> bolt -> HBase
                          -> bolt (과속여부)-> 레디스 : . 

>> 실시간 운행 로그 데이터 병렬 처리
>> 실시간 운행 로그 데이터 분석 결과 처리. 
설치

1.설치파일 다운 설치
서버 02
/home/pilot-pjt
wget http://archive.apache.org/dist/storm/apache-storm-1.2.3/apache-storm-1.2.3.tar.gz 
tar -xvf apache-storm-1.2.3.tar.gz
ln -s apache-storm1.2.3 storm

2. 설정 수정. 
cd /home/pilot-pjt/storm/conf
vi storm.yaml
# 주키퍼 정보
storm.zookeeper.servers:
 -"server02.hadoop.com"
# 스톰 작동하는데 필요한 데이터 저장소
storm.local.dir: "/home/pilot-pjt/storm/data"
# 스톰의 Nimbus 정보
nimbus.seeds: ["server02.hadoop.com"]
# Worker의 포트 포트 갯수 만큼 worker가 만들어진다. 
supervisor.slots.ports:
 -6700
# 스톰 UI 접속포트 설정. 
ui.port: 8088

3. 스톰 로그 레벨 조정 대규모 트랜잭션 데이터 유입 과도로그 오버해드 발생 때문에 수정. 
info 기본값,  -> ERROR
cd /home/pilot-pjt/storm/log4j2
vi cluster.xml
    #<Logger name="org.apache.storm.logging.filters.AccessLoggingFilter" level="info"
    <Logger name="org.apache.storm.logging.filters.AccessLoggingFilter" level="ERROR" 
    # <Logger name="org.apache.storm.logging.ThriftAccessLogger" level="info" 
    <Logger name="org.apache.storm.logging.ThriftAccessLogger" level="ERROR"
    #<Logger name="org.apache.storm.metric.LoggingClusterMetricsConsumer" level="info"   <Logger name="org.apache.storm.metric.LoggingClusterMetricsConsumer" level="ERROR"      # <root level="info"> <!-- We log everything -->
    <root level="ERROR"> <!-- We log everything -->

vi worker.xml
    #<Logger name="STDERR" level="INFO">
    <Logger name="STDERR" level="ERROR">
    </Logger>
     #<Logger name="STDOUT" level="INFO">
    <Logger name="STDOUT" level="ERROR">

4. 스톰 명령 편리하게 사용하기 위해 root 계정의 프로파일에 스톰패스 설정. 
vi /root/.bash_profile
PATH=$PATH:/home/pilot-pjt/storm/bin


수정한 root 계정의 프로파일 정보를 다시 읽어온다. 
source /root/.bash_profile

* 리눅스 명령어 안먹을떄
PATH=/usr/local/bin:/bin:/usr/bin

5. java -version 1.8 아니면 1.8로 변경
rm /usr/bin/java
rm /usr/bin/javac
ln -s /usr/java/jdk1.8.0.181-cloudera/bin/javac /user/bin/javac
ln -s /usr/java/jdk1.8.0.181-cloudera/bin/java /user/bin/java

6. 리눅스 재시작할때 스톰 자동 실행되도록 설정. 
총 3개 스톰 서비스 : Nimbus, Supervisor, UI
스크립트 출처 : https://gist.github.com/yulrizka

#!/bin/bash
# /etc/init.d/storm-nimbus
# Startup script for storm-nimbus
# chkconfig: 2345 20 80
# description: Starts and stops storm-nimbus
#. /etc/initd/functions

7. 스톰 서비스 스크립트 파일  2번서버 업로드. 
/etc/rc.d/init.d

8. 업로드 세 파일 권한 변경.  755 , log, pid 디렉터리 만들어줌
mkdir /var/log/storm
mkdir /var/run/storm

9. service/chkconfig 등록 명령 각각 실행
service storm-nimbus start
service storm-supervisor start
service storm-ui start

10 정상 구동확인
service storm-nimbus status
service storm-supervisor status
service storm-ui status

11. server02.hadoop.com:8088 모니터링. 

** service 명령어는 sbin 에있음. 
root 계정이 잘 들어가지지 않으면(일반계정접속후 root로그인) service 없다고 나옴. 
su -root 로 들어가서 사용. 

스톰 프로세스 점검 스톰도 주키퍼에 의존도가 높다. 
주키퍼의 Z노드인 /storm의 위치에 스톰의 주요 설정값이 관리되고 있기 때문이다. 
그래서 주키퍼가 작동되지 않은 상태에서 스톰을 실행하면 주키퍼 접속 에러가 발생, 
스톰의 서비스 실패로 이어진다. 실제 환경이라면 주키퍼가 365일 24시간 작동. 
파일럿 환경은 주의 필요. 가상머신 시작, 재시작후 반드시 주키퍼 상태 확인 필요. 
스톰 
= 카프카 스카우트 병렬처리
+ 스플릿 볼트 병렬처리 
+(
카프카스파우트
-> 스플릿볼트
-> HBase볼트
-> HBase
)에러가 나면 카프카까지 롤백기능
TupleTableConfig hTableConfig = new TupleTableConfig("DriverCarInfo", "r_key");
hTableConfig.setZkQuorum("server02.hadoop.com");
hTableConfig.setZkClientPort("2181");
hTableConfig.setBatch(false);
hTableConfig.addColumn("cf1", "date");
hTableConfig.addColumn("cf1", "car_number");
hTableConfig.addColumn("cf1", "speed_pedal");

HBaseBolt hbaseBolt = new HBaseBolt(hTableConfig);
DriverCarTopologyBuilder.setBolt("HBASE", hbaseBolt,1).shuffleGrouping("splitBolt");
# 1 >> HBase 병렬처리. 

 

728x90

 

radis http://www.radis.io/
Remote Dictionary Server
1. 분산 캐시 시스템
2. NoSql 처럼 Key -Value 관리. ::: 분산서버 메모리 저장, 고성능 응답속도
3. Hbase 와 달리. 대규모 메시지데이터중 특정 데이터를 저장함. 
라이센스 BSD
유사프로젝트 jBoss Infinispan, MemCahshed, Mambase
주요
구성요소
Master 분산 노드 간의 데이터 복제와 Slave서버의 관리를 위한 마스터 서버
Slave 다수의 Slave서버는 주로 읽기 요청을 처리하고, Master서버는 쓰기 요청을 처리. 
Sentinel 레디스 3.x부터 지원하는 기능으로 Master 서버에 문제가 발생할 경우 새로운 Master를 선출 하는 기능
Replication Master서버에 쓰인 내용을 Slave서버로 복제해서 동기화 처리
AOF/Snapshot 데이터를 영구적으로 저장하는 기능으로, 명령어를 기록하는 AOF와 스냅샷 이미지 파일 방식을 지원. 
아키텍처




Sentinel. 
3.x Master 장애시. SPOF(Single point of failure) 모니터링 하고 있다 마스터 장애시 슬래이브중 하나 마스터로 선출. 
활용방안 운행자로그 400KB/초
-> 플럼 -> 카프카->스톰 
스톰-> HBase(HRegionServer (HRegion(Driver Info1,2...)))
스톰-> 레디스(Master 과속 Driver1, 2...N)
>> 과속한 운전자의 실시간 운행정보 적재
>> 과속한 운전자의 운행정보를 빠르게 검색 및 조회 .  

요구사항-> 아키텍처 -> SW -> 활용하는 비지니스 이해. 
레디스 설치 CM에서 radis 설치지원안함. 
1. 서버2 root계정으로 gcc, tcl 설치.  완료시 "Complete!"
$yum install -y gcc*
$yum install -y tcl


* 상기 에러시. 
$rm /etc/yum.repos.d/cloudera-manager.repo
echo "https://vault.centos.org/6.10/os/x86_64/" > /var/cache/yum/x86_64/6/base/mirrorlist.txt
echo "http://vault.centos.org/6.10/extras/x86_64/" > /var/cache/yum/x86_64/6/extras/mirrorlist.txt
echo "http://vault.centos.org/6.10/updates/x86_64/" > /var/cache/yum/x86_64/6/updates/mirrorlist.txt

2. 레디스5.0.7 설치
$cd /home/pilot-pjt
$wget http://download.redis.io/releases/redis-5.0.7.tar.gz

$ tar -xvf radis-5.0.7.tar.gz

$cd /home/pilot-pjt/redis-5.0.7
$make
$make install
$cd /home/pilot-pjt/redis-5.0.7/utils
$chmod 755 install_server.sh                      실행권한. 
마지막으로 인스톨 스크립트실행 엔터키
$./install_server.sh
인스턴스의 포트, 로그, 데이터 파일 설정값 위치 정보물어봄 그대로 유지 엔터. 
설치 확인 서버 기동여부 확인
vi /var/log/radis_6379.log


설치 점검
cd /home/pilot-pjt/redis-5.0.7/utils


$service redis_6379 status



레디스 서비스 시작/종료하는 명령
시작 
$service redis_6379 start
$service redis_6379 stop
원격접근 설정
1. 바인딩 ip제한해제
# bind 127.0.0.1
2. 패스워드 입력 해제
#protected-mode yes

protected-mode no

3. 재시작
service redis_6379 restart
레디스 CLI $redis-cli
$set key:1 Hello!Big
$get key:1
$del key:1
$quit
레디스 볼트 
: 레디스 캐시에 전송

레디스 데이터 전송, 제디스 클라이언트. 

#JedisPoolConfig >> 레디스 클라이언트 라이브러리 
String redisServer = "server02.hadoop.com";
int redisPort = 6379;
JedisPoolConfig jedisPoolConfig = new JedisPoolCongig.Builder().setHost(redisServer)/
setPort(redisPort).build();

RedisBolt redisBolt = new RedisBolt(jedisPoolConfig);

driverCarTopologyBuilder.setBolt("REDIS", redisBolt, 1).shuffleGrouping("esperBolt");

String date = input.getStringByFiled("date");
String car_number = input.getStringByFiled("car_number");

JedisCommands jedisCommands = null;

jedisCommands = getInstance();
jedisCommands.sadd(date, car_number);
jedisCommands.expire(date, 604800); #7일


public void run(){
    Set<String> overSpeedCarList = null
    int cnt =1;
    try{
        while(true){
            overSpeedCarList = jedis.smembers(key);
            if(overSpeedCarList.size()n > 0){
                for(String list : overSpeedCarList){
                    System.out.println(list);
                }
                jedis.del(key);
            } else {
                System.out.println("\nEmpty Car List .... \n");
            }
        }
    } 
}


-----------------------------------------------------------------------------

public  class RedisBolt extends AbstractRedisBolt {

private static final long serialVersionUID = 1L;

public RedisBolt(JedisPoolConfig config) {
super(config);
}

public RedisBolt(JedisClusterConfig  config) {
super(config);
}


@Override
public void execute(Tuple input) {

String date = input.getStringByField("date");
String car_number = input.getStringByField("car_number");

JedisCommands jedisCommands = null;

try {

jedisCommands = getInstance();
jedisCommands.sadd(date, car_number);

jedisCommands.expire(date, 604800);

} catch (JedisConnectionException e) {
throw new RuntimeException("Exception occurred to JedisConnection", e);
} catch (JedisException e) {
System.out.println("Exception occurred from Jedis/Redis" + e);
} finally {

if (jedisCommands != null) {
returnInstance(jedisCommands);
}
this.collector.ack(input);
}
}

@Override
public void declareOutputFields(OutputFieldsDeclarer declarer) {
}
}
   
   

Replication 사본

Sentinel 보초병, 감시병

실시간데이터

1. 마켓팅

2. 리스크 관리

- FDS(Fraud Detection System) : 사기방지 시스템

- 개인/기업 예측

- 해커 공격 

- 투자, 펀드

728x90

ACID atomicity, consistency, isolation, durability
원자성, 일관성, 고립성, 지속성
관계형 데이터의 원칙. 이를 위해 많은 리소스 사용. 
NoSQL 은 ACID 지키지 않음 , Key Value 구조. 단순화 , 쓰기 읽기 가능하게. 
HBase http://hbase.apache.org/
하둡 HDFS위에 만들어진 분산 컬럼지향 NoSQL 데이터베이스
스키마변경 자유롭다. 실시간 임의 읽기/쓰기 제공, 복제기능 지원. 성능 안정성 보장.  
라이센스 Apache
유사 프로젝트 BigTable, Cassandra, MongoDB
주요 
구성요소
HTable 칼럼 기반 데이터 구조를 정의한 테이블
공통점이 있는 칼럼들의 그룹을 묶은 칼럼패밀리와
테이블의 로우를 식별해서 접근하기 위한 로우키로 구성
cf) 관계형데이터베이스는 로기반, 1~10번 컬럼. 10번만 보려고해도 1~9까지봐야함. 
컬럼기반 데이타 구조는. 10번 다이렉트 참조 가능. 빠른 스캔가능 
HMaster (서버) HRegion 서버를 관리하며, HRegion들이 속한 HRegion 서버의 메타 정보를 관리. 
HRegion (서버) HTable의 크기에 따라 자동으로 수평분할이 발생하고, 이때 분할된 블록을 HRegion 단위로 지정
HRegionServer 분산 노드별 HRegionServer가 구성되며, 하나의 HRegionServer에는 다수의 HRegion이 생성되어  HRegion을 관리
Store 하나의 Store에는 칼럼 패밀리가 저장 및 관리되며, MemStore와 HFile로 구성됨. 
MemStore Store 내의 데이터를 인메모리에 저장 및 관리하는 데이터 캐시영역
HFile Store 내의 데이터를 스토리지에 저장 및 관리하는 영구 저장영역. 
아키텍처


분산데이타베이스 아키텍처
클라이언트 -> 주키퍼 통해 HMaster 접근.  HTable 기본정보 해당 HRegion 정보 알아냄
 클라이언트 HRegionSever 액세스. 
  MemStore 데이터 기록. 특정크기되면 -> HFile -> 하둡저장 
: compaction(컴팩션, 꽉채움) : 파일 뭉치기. 
minor - compaction :  최근 생성된 작은 파일들을 큰파일로 재작성. 
- hbase.hstore.compaction.min   , 기본3,  큰값을 넣으면 minor 지연, 나중에 부하가능성. 
- hbase.hstore.compaction.max  , 
- hbase.hstore.compaction.min.size,
major - compaction : 모든 파일을 하나의 파일로 구성
- hbase.hregion.majorcompaction.jitter  기본 0.2 (20%), 

출처: https://datacookbook.kr/40 [DATA COOKBOOK]

활용방안 운잔자 운행로그 400kb/1초
-> 플럼-> 카프카-> 스톰
-> HBase
HRegionServer1 - HRegion1 (Driver Info1, 4)
HRegionServer2 - HRegion2 (Driver Info2, 5)
HRegionServer3 - HRegion3 (Driver Info3, ....)
-> 스마트카 운전자의 실시간 운행정보 적재
     운전자의 운행 정보를 빠르게 검색 및 조회 . 

카프카 : MoM: 대규모 메시지 버퍼링, 메시지 오리엔티드 미들웨어 시스템
Topic 비동기 저장. 
스톰: 카프카 데이터 빼냄. . 카프카의 컨슈머. 
       병렬분산.... 스톰이 빼온 데이터 Hbase에 저장. 
설치 1. 설치
CM 홈 >클러스터 콤보박스 > Add Service
> Master , HBase Thrift Server , RegionServer -> 02서버로 설정
> 설정 default 값.   복제, 인덱스 사용 설정 참고. 
> HBase 컴포넌트는  하둡의 얀 위에 설치

2. 환경설정
---HBase Thrift Http 서버 활성화 ----
HBase > 구성 > 
HBase Thrift Http서버설정(hbase.regionserver.thrift.http
Enable HBase Thrift Http Server(hbase.thrift.ssl.enabled)
:  HBase (Service-Wide) : 서비스 전체 활성화

3. HBase 서비스 시작 or 재시작
>>Master서버 3개의 Region Server기동화면 활성화됨. 

4. HBase 처럼 규모가 있는 컴포넌트 설치되면 이미 설치되 소프트웨어(주키퍼, HDFS,YARN, 등) 클라이언트 설정값 변동발생, 클라이언트 구성 재배포(Re-deploy client configuration) 통해 변경사항 반영. 

5. 정상설치확인
서버2번 접속

$hbase shell
$create 'smartcar_test_table' , 'cf'
$put 'smartcar_test_table', 'row-key1', 'cf:model', 'z0001'
$put 'smartcar_test_table', 'row-key1', 'cf:no', '12345'

$get 'smartcar_test_table', 'row-key1'

** 테이블은 disable 후 삭제가능
$disable 'smartcar_test_table'
$drop 'smartcar_test_table'

$exit

6. HBase 관리자 화면. 
CM  > HBase > WebUI
http://server02.hadoop.com:16010/master-status

HBase는 자원소모가 높은 서버로 사용않을때는일시정지

RegionSplit 분산되어 있는 Hbase 내부에 리전이 만들어짐. 
내부 리전이 분산되도록 함.  = 샤딩. 
리젼..여러 스플릿 정책. 
ex) 사이즈 리전 스플릿 과거. ,  이클립스 인투 오퍼 바운더리 리전정책 사용. 
특정테이블 만들고 초기 대규모 데이터 예상되면 미리 스플릿하는게 좋음. 
$hbase org.apache.hadoop.hbase.util.RegionSpllitter DriverCarINfo HexStringSplit -c 4 -f cf1
# 고사양 4, 저사양 2
# cf1 : 컬럼패밀리... 대상으로 리전 스플릿. 
   
   
   

atomicity 아토믹씨티 원자성. 

 

728x90
수업진행.  1. 빅데이터 실시간 적재 개요
2. 빅데이터 실시간 적재에 활용하는 기술
3. 실시간 적재 파일럿 실행 1단계 -실시간 적재 아키텍쳐
4. 실시간 적재 파일럿 실행 2단계 -실시간 적재 환경구성
5. 실시간 적재 파일럿 실행 3단계 -실시간 적재기능구현  >Hbase , 레디스
6. 신시간 적재 파일럿 실행 4단계 -실시간 적재 기능 테스트.  >카프카 스톰
실시간 적재 개요 수집 -> 적재-대용량(배치성처리)    -> (처리/탐색 -> 분석/응용)  
       -> 전재-메시지(실시간성 처리) 

1. 실시간데이터
데이터 실시간== 빠르고, 오랜시간, 대규모
==> 실시간 적재 실시간 분석... 수억건 데이터이기 때문. 
2. 안정적으로
==> 장애... 시 유실. 
적재 저장소 유형 1. 내/외부 원천데이터
정형 데이터 : 데이터베이스
                 (관계/계층/객체/네트워크)
반정형 데이터 : HTML, XML, JSON, 서버로그
비정형 데이터 : 소셜미디어, 문서, 이미지, 오디어 , 비디오 , IOT

-------------->           
배치수집
실시간 수집
--------------> 
2, 적재 저장소 유형. 
- 배치처리 : 큰파일
대용량 파일 전체를 영구 저장 - 분산파일 시스템
- 실시간처리 : 작은메시지
대규모 메시지 전체를 영구저장 -No-SQL  :Hbase, 카산드라, 몽고DB
대규모 메시지 전체를 버퍼링처리 - MoM : 카프카 
대규모 데이터 일부만 임시저장 - Cached : 인메모리 캐시시스템 : 레디스.
실시간 적재 요구사항 요구사항1. 차량의 다양한 장치로부터 발생하는 로그 파일을 수집해서 기능별 상태점검
요구사항2. 운전자의 운행정보가 담긴로그를 실시간으로 수집해서 주행패턴을 분석한다. 
실시간적재 요구사항
구체화
1. 1초간격으로 발생하는 100명의 운행정보(운행정보1건:약 4kb)손실없이 적재해야한다. 
>>카프카와 스톰을 이용해 수집한 데이터에 대해 분산 처리 및 무결성을 보장하며, 분산처리가 완료된 데이터는 HBase에 적재
2. 적재한 운행정보를 대상으로 조건 검색이 가능해야 하며, 필요시 수정도 가능해야 한다. 
>> HBase의 테이블에 적재된 데이터는 스캔 조건으로 검색하며, 저장(Put) 기능을 이용해 기적재한 데이터에 대해 칼럼 기반으로 수정. 
3. 운전자의 운행정보 중 30초를 기준으로 평균 속도가 80km/h 초과한 정보는 분리 적재한다. 
>> 에스퍼의 EPL 에서 사용자별로 운행정보를 그루핑하고, 30초의 윈도우 타임(Window Time) 조건으로 평균 시속 집계 및 임계치별 이벤트를 정의 
4. 과속한차량을 분리 적재하기 위한 조건은 별도의 룰로 정의 하고 쉽게 수정할수 있어야 한다. 
>> 과속 기준을 80Km/h에서 100Km/h로 변경해야 할 경우 EPL의 평균 속도를 체크하는 조건값만 수정
5. 분리 적재한 데이터는 외부 애플리케이션이 빠르게 접근하고 조회할수 있게해야 한다. 
>> 실시간 이벤트로 감지된 데이터는 인메모리 기반 저장소인 레디스에 적재해서 외부 애플리케이션에서 빠르게 조회 
6. 레디스에 적재한 데이터는 저장소의 공간을 효율적으로 사용하기 위해 1주일이 경과하면 영구적으로 삭제
>> 레디스 클라이언트 라이브러리인 제디스(Jedis)클라이언트를 이용해 데이터 적재 시 만료(Expire)시간을 설정해 자동으로 영구 삭제 처리. 
실시간 적재 아키텍처 운전자 운행로그 4kb/1초
-> 플럼에이전트2: ->Exec-Tail Source-> Memory Channel-> kafka Sink
-> 카프카 :Topic 
-> 스톰: 카프카 Spout -> Bolt/에스퍼 -> 레디스 Bolt, HBase Bolt
   -> 레디스 :과속운전자 정보
   -> HBase : 모든 운전자의 운행정보. 
1. Hbase설치 https://blog.1028web.com/entry/big-hbase
   
   
   

 

Tip_ 오픈소스 컴플라이언스 이슈

빅데이터의 소프트웨어들은 대부분 오픈소스

하둡중심 대부분 아파치 .. 제약사항이 적어 다양한비즈니스 적용 크게 문제안됨. 

GPL, AGPL .. 에스퍼가 GPL2.0 소스 "라이센스 양립성" 상용시스템 에스퍼 적용시 공개의무.. 때문에 주의할필요. 

https://www.olis.or.kr/license/compareGuide.do

라이선스 주요내용

라이선스 이름 복제, 배포, 수정의 권한허용 배포시라이선스사본첨부 저작권고지사항또는Attribution고지사항 유지 배포시소스코드제공의무와범위 조합저작물작성 및타 라이선스배포허용 수정내용 고지 명시적특허라이선스의허용 라이선시가특허소송 제기시라이선스종료 이름,상표,상호에 대한사용제한 보증의 부인 책임의 제한
Apache License 1.1 O   O   조건부       O O O
Apache License 2.0 O O O   O   O O O O O
GNU General Public License 2.0 O O O 전체 코드 조건부         O O
GNU General Public License 3.0 O O O 전체 코드   O O O   O O
GNU Lesser General Public License 2.0 O O O 2차 저작물 O O       O O
GNU Lesser General Public License 3.0 O O O 2차 저작물 O O O O   O O
MIT License O O O   조건부         O O
  • ※ 참고사항
  • 기여자(contributor)의 범위에는 최초개발자도 포함
  • 배포에서의 상호주의(Reciprociy)란
  • 라이선스 적용코드를 제3자에게 배포할 때 원 라이선스와 동일한 라이선스로 배포하도록 요구하는 조항을 말하며,
  • 보통 Copyleft 조항이라고도 함.
  • 조합저작물(Larger Work)이란
  • 라이선스 적용 코드 전체나 그 일부를 본 라이선스의 적용을 받지 않는 코드와 결합한 저작물을 의미한다.
  • 빈칸은 해당 라이선스에 명시적으로 언급이 없음을 의미한다.
  • 그러나 언급이 없더라도 묵시적으로 허용하거나, 금지하는 것으로 해석할 수 있으므로, 관련 전문가와 상의하기 바랍니다.

주요 오픈 라이선스의 GPL 호환성

??? 문제가 있다는건가 있다 or 없다. 

오픈 소스 소프트웨어 라이선스 GPL 2.0 호환 GPL 3.0 호환
Academic Free License No No
Affero GNU General Public License version 3.0 No Yes
Apache License version 1.0 No No
Apache License version 1.1 No No
Apache License version 2.0 No Yes
original BSD license No No
GNU General Public License 2.0 Yes No
GNU General Public License 3.0 No Yes
GNU Lesser General Public License Yes Yes
MIT license Yes Yes
Mozilla Public License version 1.1 No No
Mozilla Public License version 2.0 Yes Yes
728x90

주키퍼 http://zookeeper.apache.org/
Hbase, Kafka, Hadoop.. 범용적인 분산 코디네이터. 
라이센스 Apache
유사프로젝트 Chubby, Doozerd, Consul
주요
구성요소
Client 주키퍼의 ZNode에 담긴 데이터에 대한 쓰기, 읽기, 삭제 등의 작업을 요청하는 클라이언트
주요
구성요소
- 서버
Ensemble 3대 이상의 주키퍼 서버를(**홀수 구성) 하나의 클러스터로 구성한 Ha아키텍처
ZNode 주키퍼 서버에 생성되는 파일시스템의 디렉터리 개념으로, 
클라이언트의 요청 정보를 계층적으로 관리
(버전, 접근 권한, 상태, 모니터링 객체 관리등의 기능지원)
Leader
Server
Ensemble 안에는 유일한 리더 서버가 선출되어 존재하며, 클라이언트의 요청을 받은 서버는 해당 요청을 리더 서버에 전달하고, 리더 서버는 모든 팔로워 서버에게 클라이언트 요청이 전달되도록 보장. 
Follower
Server
Ensemble 안에서 한 대의 리더 서버를 제외한 나머지 서버로서, 리더 서버와 메시지를 주고 받으면서 ZNode의 데이터를 동기화 하고 리더 서버에 문제가 발생할 경우 내부적으로 새로운 리더를 선출하는 역할 수행. 
아키텍처


Client : 분산 서버.  공유할정보가 있으면 주키퍼 앙상블에 기록을하자 약속. 
          특정 분산서버 수정하면 FloowerServer에 작성.. -> 리더서버 전달. -> 나머지 싱크 맞춤. 

주키퍼 앙상블
- 환경설정정보 동기화, 
: 메타정보 로드발란싱(동기화), 패이로버(한대 죽어도 나머지 살아있어사용가능)
: 클러스터 1번~N번  서버정보 맴버쉽으로 묶어 주키퍼에 기록해놓고 있음. 
:클러스터 맴버십 관리
4번서버 장애 > 주키퍼에 4번서버정보 삭제됨. 

- 분산락 : 분산서버는 반드시 마스터가 필요함. 
Client1 마스터 지정.    주키퍼에 서버1 마스터락을받음.  나머지는 락번호낮음
마스터가 장애가 나면, 전체 클러스터문제 >> 다른 서버 마스터 지정.(그다음 락 낮은번호 자동지정) 
- 마스터 선출 
활용방안 스마트카 파일럿 프로젝트에서는 주키퍼를 직접적으로 활용하지 않는다. 
하둡, HBase, 카프카, 내부에서 주키퍼에 의존해 클러스터 멤버십 기능 및 환경설정의 동기화 등을 사용하고 있어 없어서는 안될 중요 소프트웨어다. 
     
728x90

하둡 https://hadoop.apache.org/

1. 대용량 데이터 분산저장
2. 분산 저장된 데이터를 가공/분석 처리하는기능. 
라이센스 Apache
유사프로젝트 GS(Google File System), Gluster, MogileFS 모자일FS, GridFS, Lustre 러스터
주요
구성요소
DataNode 블록(64MB or 128MB 등) 단위로 분할된 대용량 파일들이 DataNode의 디스크에 저장 및 관리
... 서버...
NameNode DataNode에 저장된 파일들의 메타 정보를 메모리상에서 로드해서 관리. 
EditsLog 에디트로그 파일들의 변경 이력(수정, 삭제 등) 정보가 저장되는 로그파일
FsImage  NameNode 메모리상에 올라와 있는 메타정보를 스냅샵이 이미지로 만들어 생생한 파일
주요
구성요소
Ver.1x
SecondaryNameNode NameNode의 FsImage, EditsLog 파일을 주기적으로 유지관리해 주는 체크포인팅 노드. 
MapReduce v1 DataNode에 분산 저된 파일이 스프릿(Map)되어 다양한 연산(정렬, 그루핑, 지계) 수행한 뒤 그 결과를 다시 병합(Reduce) 하는 분산 프로그래밍 기법
JobTracker 맵류듀스의 잡을 실행하면서 태스크에 할당하고,
전체 잡에 대해 리소스 분배 및 스케줄링
TaskTracker JobTracker가 요청한 맵 리듀스 프로그램이 실행되는 태스크이며,
이때 맵 태스크와 리듀스 태스크 생성. 
주요
구성요소
Ver.2x
Active/Stand-ByNameNode NameNode를 이중화 해서 서비스 중인Active NameNode와
실패 처리를 대비한 Standby NameNode로 구성
MapReduce v2/YARN 하둡 클러스터 내의 자원을 중앙 관리하고, 그 위에 다양한 애플리케이션 실행 및 관리가 가능하도록 확장성과 호환성을 높인 하둡2.x플랫폼
ResourceManager 하둡 클러스터 내의 자원을 중앙 관리하면서, 작업 요청 시 스케줄링 정책에 따라 자원을 분배해서 실행시키고 모니터링. 
NodeManager 하둡 클러스터의 DataNode마다 실행되면서 Container를 실행 시키고 라이프 사이클 관리
주요
구성요소
Ver.2x 2
Container DataNode의 사용가능한 리소스(CPU, 메모리, 디스크 등)을 Container 단위로 할당해서 구성. 
ApplicationMaster 애플리케이션 실행되면 ApplicationMaster가 생성되며, ApplicationMaster는 NodeManager에게 애플리케이션이 실행될 Container를 요청하고 그 위에서 애플리케이션을 실행 및 관리. 
JournalNode 3개 이상의 노드로 구성되어 EditsLog를 각 노드에 복제 관리하며 Active NameNode는 EditisLog에 쓰기만을 수행
아키텍처

클라이언트 Case1 :  1TB   
- 데이터노드: 각각,.... 블록단위 저장(기본 128M) * 3복제 
- 네임노드: 데이터정보 보유,
- 세컨터리네임노드: 네임노드 백업 관리 유지
- 잡 트랙커 : 맵리듀스, 테스크 트랙커 관리 실행 모니터링
클라이언트 Case2 : 특정정보 추출원하면 맵리듀스 에 일을시켜결과를 뽑아옴.   

2.x : 1.x 안전성, 범용성 올라감. 
주키퍼 : 분산 코디네이터 : 네임노드 Active, StandBy 에대해 가용성에대한 포지션. 
- 네임노드 : Active, StandBy 구조로 바뀜. 
- 저널로드
리소스메니저 : 데이터노드 자원관리
- 데이터노드
- 노드 매니저 안에 컨테이너가 존재
- 컨테이너 : 위해 얀을 기반으로한 다양한 어플리케이션 사용. 
- 어플리케이션 마스터: 얀위에 어플리케이션 실행마다 생김.  분산 실행 컨테이너의 어플리케이션 관리. 

하둡 2.x  네임노드 엑티브 스탠바이로 사용가능. 이전에는 서드파티 도구 사용. 
맵리듀스에 얀 리소스메니저나오면서 ... 얀 라이프사이클 지키면 하둡에 데이터노드에 다양한 소프트웨어 테스크사용가능
활용 방안 스마트카 상태정보(100MB/1일)
-수집-> 플럼 -적재-> 하둡(DataNode 1~3))

DataNode 1~3
= HDFS(스마트카 상태정보 파티션나눠 일단위) + 맵 리듀스. 
 
==> 스마트카의 상태정보 장기적재
       일/주/월/년 단위 시계열분석
하둡의 맵 리듀스 분산 병렬 처리에서 핵심은 맵리듀스...
1. 여러 컴퓨터 분산 저장돼 있는 데이터로부터 어떻게 효율적으로 일을 나눠서 (Map)실행시킬수 있느냐,
2. 여러 컴퓨터가 나눠서 실행한 결과들을 어떻게 하나로 모으냐(Reduce)

이를 쉽고 편리하게 지원하는 프레임워크가 하둡의 맵리듀스. 

            ->  Server1  Map1       Server 11
고객정보 -> Server2  Map2   --> Vip고객  Reduce1  -> Vip 평균영봉. 
  (1TB)    -> Server3   Map3        (50MB)                    (1KB)
            ->   ...
             -> Server10  Map10

 분석가 : 분석쿼리 Map 에 명령 전달... 프로그램이 이동
일반적 : DB를 메모리 올려 처리. 
     
     
     
     
     
     
728x90
강의 개요 1. 빅데이터 적재 개요_ 빅데이터 대용량 파일 적재의 기본 개념 설명
2. 빅데이터 적재에 활용하는 기술 _ 하둡, 주키퍼에 대한 소개 , 기술별 주요 기능, 아키텍처 활용방안
3. 적재 파일럿 실행 1단계 _ 적재 아키텍처  : 로그파일 적재와 관련한 요구사항 구체화, 파일럿 아키 설명
4. 적재 파일럿 실행 2단계 _ 적재 환경구성 : 스마트카 로그 파일 적재 아키텍처를 설치 및 환경구성
5. 적재 파일럿 실행 3단계 _ 적재 기능구현 : 플럼이용해 스마트카 생태정보 르그파일 하둡적제기능구현
6. 적재 파일럿 실행 4단계 _ 적재 기능 테스트 : 로그 시뮬레이터 이용해 스마트카 상태 정보 데이터 발생, 플럼이 해당 데이터를 HDFS정상적재 확인
적재 유형 수집 -> 적재(배치성) -> (처리 /탐색 -> 분석/응용) : 배치성.
      -> 적재(실시간성)-> 

적재- 대용량 : 배치성 처리
적재- 메시지 : 실시간성 처리.  
적재 저장소 유형 1. 내/외부 원천데이터
정형 데이터 : 데이터베이스
                 (관계/계층/객체/네트워크)
반정형 데이터 : HTML, XML, JSON, 서버로그
비정형 데이터 : 소셜미디어, 문서, 이미지, 오디어 , 비디오 , IOT

-------------->           
배치수집
실시간 수집
--------------> 
2, 적재 저장소 유형. 
- 배치처리 : 큰파일
대용량 파일 전체를 영구 저장 - 분산파일 시스템
- 실시간처리 : 작은메시지
대규모 메시지 전체를 영구저장 -No-SQL  :Hbase, 카산드라, 몽고DB
대규모 메시지 전체를 버퍼링처리 - MoM : 카프카 
대규모 데이터 일부만 임시저장 - Cached : 인메모리 캐시시스템 : 레디스.

에코시스템 : 생태계 

 

적재 요구사항 1. 차량의 다양한 장치로부터 발생하는 로그 파일을 수집해서 기능별 상태를 점검한다. 
>> 배치
2. 운전자의 운행정보가 담긴 로그를 실시간으로 수집해서 주행패턴을 분석한다 
>> 운전자 운행로그. 이벤트로그 실시간. 
적재 요구사항 
구체화
1. 100대에 달하는 스카트카들의 상태정보가 일단위로 취합
>> 플럼에서 수집 발생시점의 날짜를 HdfsSink에 전달해서 해당 날짜 단위로 적재
logSink -> HdfsSink
2. 매일 100 대의 스마트카 상태 정보는 약 100MB정도이며 220만건의 상태정보 발생
>> 1년 적재시 8억건 이상의 데이터가 적재되며, 연 단위분석에 하둡의 분산병렬처리사용. 
3. 스마트카의 상태 정보 데이터의 발생일과 수집/적재되는 날짜가 다를수 있다. 
>> 수집/적재되는 모든 데이터마다 데이터 발생일 외에 수집/적재 처리돼야 하는 처리일 추가. 
4. 적재된 스마트카들의 상태 정보를 일/월/년 단위로 분석할수 있어야 한다. 
>> HDFS에 수집 일자별로 디렉터리 경로를 만들어 적재.
5. 적재 및 생성되는 파일은 HDFS의 특성을 잘 고려해야 한다. 
>> 플럼의 HdfsSink의 옵션을 파일럿 프로젝트의 HDFS에 최적화 해서 설정
6. 적재과 완료된 후에는 원천 파일이 삭제되어야 한다. 
>> 플럼Source 컴포넌트 중 SpoolDir DeletePolicy 옵션을 활용.  
적재 아키텍처


차량상태정보 100MB/1일
-> 플럼에이전트(SpoolDir Source -> Memory Cannel-> HDFS Sink)
-> 일단위 적재 -> 하둡

하둡:
-NameNode
-DataNode
- HDFS : 경로   ... 일별분석, 주, 워별분석.. 년별분석
-맵리듀스
 
하둡 설치 확인
CM> HDFS 상세 > DataNode > DataNode웹ui
URL : http://server01.hadoop.com:9870/dfshealth.html
CM> YARN 상세 > 웹ui > 리소스메니저
리소스매니저 :  http://server01.hadoop.com:8088/cluster
CM> YARN 상세 > 웹ui > 히스토리
잡 히스토리 : http://server01.hadoop.com:19888/jobhistory

cf_ http://server01.hadoop.com:7180/  클라우데라 매니저. 
적재기능구현
-스마트카
에이전트수정. 
SmartCar_Agent.sources  = SmartCarInfo_SpoolSource DriverCarInfo_TailSource
SmartCar_Agent.channels = SmartCarInfo_Channel DriverCarInfo_Channel
SmartCar_Agent.sinks    = SmartCarInfo_HdfsSink DriverCarInfo_KafkaSink


SmartCar_Agent.sources.SmartCarInfo_SpoolSource.type = spooldir
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.spoolDir = /home/pilot-pjt/working/car-batch-log
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.deletePolicy = immediate
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.batchSize = 1000


SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors = timeInterceptor typeInterceptor collectDayInterceptor filterInterceptor

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.timeInterceptor.type = timestamp
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.timeInterceptor.preserveExisting = true

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.typeInterceptor.type = static
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.typeInterceptor.key = logType
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.typeInterceptor.value = car-batch-log

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.collectDayInterceptor.type = com.wikibook.bigdata.smartcar.flume.CollectDayInterceptor$Builder

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.type = regex_filter
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.regex = ^\\d{14}
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.excludeEvents = false

SmartCar_Agent.channels.SmartCarInfo_Channel.type = memory
SmartCar_Agent.channels.SmartCarInfo_Channel.capacity  = 100000
SmartCar_Agent.channels.SmartCarInfo_Channel.transactionCapacity  = 10000


SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.type = hdfs
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.path = /pilot-pjt/collect/%{logType}/wrk_date=%Y%m%d
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.filePrefix = %{logType}
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.fileSuffix = .log
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.fileType = DataStream
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.writeFormat = Text
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.batchSize = 10000
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.rollInterval = 0
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.rollCount = 0
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.idleTimeout = 100
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.callTimeout = 600000
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.rollSize = 67108864
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.hdfs.threadsPoolSize = 10


SmartCar_Agent.sources.SmartCarInfo_SpoolSource.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks.SmartCarInfo_HdfsSink.channel = SmartCarInfo_Channel


SmartCar_Agent.sources.DriverCarInfo_TailSource.type = exec
SmartCar_Agent.sources.DriverCarInfo_TailSource.command = tail -F /home/pilot-pjt/working/driver-realtime-log/SmartCarDriverInfo.log
SmartCar_Agent.sources.DriverCarInfo_TailSource.restart = true
SmartCar_Agent.sources.DriverCarInfo_TailSource.batchSize = 1000

SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors = filterInterceptor2
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.type = regex_filter
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.regex = ^\\d{14}
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.excludeEvents = false

SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.type = org.apache.flume.sink.kafka.KafkaSink
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.topic = SmartCar-Topic
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.brokerList = server02.hadoop.com:9092
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.requiredAcks = 1
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.batchSize = 1000


SmartCar_Agent.channels.DriverCarInfo_Channel.type = memory
SmartCar_Agent.channels.DriverCarInfo_Channel.capacity= 100000
SmartCar_Agent.channels.DriverCarInfo_Channel.transactionCapacity = 10000


SmartCar_Agent.sources.DriverCarInfo_TailSource.channels = DriverCarInfo_Channel
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.channel = DriverCarInfo_Channel
플럼의 사용자정의 Interceptor 추가 /opt/cludera/parcels/CDH/lib/flume-ng/lib  파일업로드. bigdata.smartcar.flume-1.0.jar
  0. 시뮬레이터 실행. 
cd /home/pilot-pjt/working
$ java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.CarLogMain 20160102 100 &
$ tail -f /home/pilot-pjt/working/SmartCar/SmartCarStatusInfo_20160102.txt

-이번엔통과
$ java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.DriverLogMain 20160102 3 &
$ tail -f /home/pilot-pjt/working/driver-realtime-log/SmartCarDriverInfo.log

1. 일간 로그파일을  플럼 SmartCarInfo 에이전트의 SpoolDir 경로로 옮긴다. 
 SpoolDir (car-batch-log) -> Channel -> HDFS Sink -> HDFS
$ mv /home/pilot-pjt/working/SmartCar/SmartCarStatusInfo_20160102.txt /home/pilot-pjt/working/car-batch-log/

--안되서.ㅜㅜ cp로... 필요없음 통과. 
cp /home/pilot-pjt/working/SmartCar/SmartCarStatusInfo_20160102.txt /home/pilot-pjt/working/car-batch-log/
$cd /home/pilot-pjt/working/car-batch-log/
$ls -ltr

3. 플럼로그 정상확인
$tail -f /var/log/flume-ng/flume-cmf-flume-AGENT-server02.hadoop.com.log


2021-05-27 13:14:27,620 INFO org.apache.flume.sink.hdfs.BucketWriter: Creating /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824229.log.tmp
2021-05-27 13:14:55,557 INFO org.apache.flume.client.avro.ReliableSpoolingFileEventReader: Last read took us just up to a file boundary. Rolling to the next file, if there is one.
2021-05-27 13:14:55,557 INFO org.apache.flume.client.avro.ReliableSpoolingFileEventReader: Preparing to delete file /home/pilot-pjt/working/car-batch-log/SmartCarStatusInfo_20160102.txt
2021-05-27 13:16:40,491 INFO org.apache.flume.sink.hdfs.BucketWriter: Closing idle bucketWriter /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824229.log.tmp at 1622089000491
2021-05-27 13:16:40,491 INFO org.apache.flume.sink.hdfs.HDFSEventSink: Writer callback called.
2021-05-27 13:16:40,491 INFO org.apache.flume.sink.hdfs.BucketWriter: Closing /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824229.log.tmp
2021-05-27 13:16:40,516 INFO org.apache.flume.sink.hdfs.BucketWriter: Renaming /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824229.log.tmp to /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824229.log


Creating /pilot-pjt/ ~~  : 적재중
BucketWriter: Closing /pilot-pjt/ ~~ 
BucketWriter: Renaming /pilot-pjt/coll  ~~  :: HDFS 적재 성공적으로 끝남. 

4. hdfs 적재 확인
$hdfs dfs -ls -R /pilot-pjt/collect/car-batch-log

[root@server02 working]# hdfs dfs -ls -R /pilot-pjt/collect/car-batch-log
drwxr-xr-x   - flume supergroup          0 2021-05-27 13:27 /pilot-pjt/collect/car-batch-log/wrk_date=20210527
-rw-r--r--   1 flume supergroup   68303437 2021-05-27 13:14 /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824228.log
-rw-r--r--   1 flume supergroup   55195294 2021-05-27 13:16 /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824229.log
$hdfs dfs -cat /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824228.log
$hdfs dfs -tail /pilot-pjt/collect/car-batch-log/wrk_date=20210527/car-batch-log.1622088824228.log

플럼넣기전 :  /home/pilot-pjt/working/SmartCar/, /home/pilot-pjt/working/car-batch-log/
-rw-r--r-- 1 root root 104070631 May 27 13:11 SmartCarStatusInfo_20160102.txt
20160102000100,R0001,94,88,96,98,1,1,1,1,B,B,92
20160102000104,R0001,82,90,79,82,1,1,1,1,A,A,73
20160102000108,R0001,88,93,89,95,1,1,1,1,A,A,93
hdfs에서 : ",20210527" 끝에 작업일자 추가됨. 플럼의 인터셉터가 붙임.  104070631->64M 1개, +나머지
20160102000100,R0001,94,88,96,98,1,1,1,1,B,B,92,20210527
20160102000104,R0001,82,90,79,82,1,1,1,1,A,A,73,20210527
20160102000108,R0001,88,93,89,95,1,1,1,1,A,A,93,20210527

5. 시뮬레이터 종료. 

마치며.  1. 빅데이터 적재 개요
2. 빅데이터 적재에 활용하는 기술 : 주요기능, 이키텍처, 활용방안
3. 적재 파일럿 실행 1단계 - 적재 아키텍쳐
4. 적재 파일럿 실행 2단계 - 적재 환경구성. 
5. 적재 파일럿 실행 3단계 - 적재 기능 구현
6. 적재 파일럿 실행 4단계 - 적재 기능 테스트

 ps -ef |grep smartcar.log

 

 

https://flume.apache.org/FlumeUserGuide.html

channel  
type The component type name, needs to be hdfs
hdfs.path HDFS directory path (eg hdfs://namenode/flume/webdata/)
hdfs.filePrefix FlumeData Name prefixed to files created by Flume in hdfs directory
hdfs.fileSuffix Suffix to append to file (eg .avro - NOTE: period is not automatically added)
hdfs.inUsePrefix Prefix that is used for temporal files that flume actively writes into
hdfs.inUseSuffix .tmp Suffix that is used for temporal files that flume actively writes into
hdfs.emptyInUseSuffix false If false an hdfs.inUseSuffix is used while writing the output. After closing the output hdfs.inUseSuffix is removed from the output file name. If true the hdfs.inUseSuffix parameter is ignored an empty string is used instead.
hdfs.rollInterval 30 Number of seconds to wait before rolling current file (0 = never roll based on time interval)
hdfs.rollSize 1024 File size to trigger roll, in bytes (0: never roll based on file size)
hdfs.rollCount 10 Number of events written to file before it rolled (0 = never roll based on number of events)
hdfs.idleTimeout 0 Timeout after which inactive files get closed (0 = disable automatic closing of idle files)
hdfs.batchSize 100 number of events written to file before it is flushed to HDFS
hdfs.codeC Compression codec. one of following : gzip, bzip2, lzo, lzop, snappy
hdfs.fileType SequenceFile File format: currently SequenceFile, DataStream or CompressedStream (1)DataStream will not compress output file and please don’t set codeC (2)CompressedStream requires set hdfs.codeC with an available codeC
hdfs.maxOpenFiles 5000 Allow only this number of open files. If this number is exceeded, the oldest file is closed.
hdfs.minBlockReplicas Specify minimum number of replicas per HDFS block. If not specified, it comes from the default Hadoop config in the classpath.
hdfs.writeFormat Writable Format for sequence file records. One of Text or Writable. Set to Text before creating data files with Flume, otherwise those files cannot be read by either Apache Impala (incubating) or Apache Hive.
hdfs.threadsPoolSize 10 Number of threads per HDFS sink for HDFS IO ops (open, write, etc.)
hdfs.rollTimerPoolSize 1 Number of threads per HDFS sink for scheduling timed file rolling
hdfs.kerberosPrincipal Kerberos user principal for accessing secure HDFS
hdfs.kerberosKeytab Kerberos keytab for accessing secure HDFS
hdfs.proxyUser    
hdfs.round false Should the timestamp be rounded down (if true, affects all time based escape sequences except %t)
hdfs.roundValue 1 Rounded down to the highest multiple of this (in the unit configured using hdfs.roundUnit), less than current time.
hdfs.roundUnit second The unit of the round down value - second, minute or hour.
hdfs.timeZone Local Time Name of the timezone that should be used for resolving the directory path, e.g. America/Los_Angeles.
hdfs.useLocalTimeStamp false Use the local time (instead of the timestamp from the event header) while replacing the escape sequences.
hdfs.closeTries 0 Number of times the sink must try renaming a file, after initiating a close attempt. If set to 1, this sink will not re-try a failed rename (due to, for example, NameNode or DataNode failure), and may leave the file in an open state with a .tmp extension. If set to 0, the sink will try to rename the file until the file is eventually renamed (there is no limit on the number of times it would try). The file may still remain open if the close call fails but the data will be intact and in this case, the file will be closed only after a Flume restart.
hdfs.retryInterval 180 Time in seconds between consecutive attempts to close a file. Each close call costs multiple RPC round-trips to the Namenode, so setting this too low can cause a lot of load on the name node. If set to 0 or less, the sink will not attempt to close the file if the first attempt fails, and may leave the file open or with a ”.tmp” extension.
serializer TEXT Other possible options include avro_event or the fully-qualified class name of an implementation of the EventSerializer.Builder interface.
serializer.*    

크러스터 시작시 : 주키퍼 > 카프카> HDFS > Flume > YARN 순으로 기동. 

728x90

 

카프카 http://kafka.apache.org/
MOM(massage orianted middleware)소프트웨어,
대규모 발생 작은데이터, 비동기 방식 처리 : 분산임시 저장소 : 빅데이터 외 IOT, SNS에서도 사용. 
(Queue , Topic...이 버퍼역할, 트랜젝션처리)
라이센스 Apache
유사 프로젝트 ActiveMQ, RabbitMQ, HonnetMQ(호넷)등
주요
구성요소
Broker 카프카의 서비스 인스턴스
다수의 Broker를 클러스터로 구성하고 Topic이 생성되는 물리적서버
Topic Broker에서 데이터의 발생/소비 처리를 위한 중간저장소
Provider Broker의 특정 토픽에 데이터를 전송(발행)하는 역할로, 애플리케이션에서 카프카라이브러리를 이용해 구현
Consumer Broker의 특정 Topic에서 데이터를 수신(소비)하는 역할로서 애플리케이션에서 카프카 라이브러리를 이용해 구현. 
아키텍처 1
싱글 브로커 온 
싱글노드
** 모두 주키퍼 활용
아키텍처2
멀티 브로커 싱글노드
- 업무도메인 복잡한 메시지 처리시 사용. 
아키텍처3
멀티브로커/멀티노드
: 실제 많이 사용
Topic 1-2 ~Topic2-1 묶을수 있다. 

-대규모 메시지 있을때 
대규모 컨슈머가 있어야 안정성
-대규모 발행소비 적합
- 물리적 나눠진 브로커간 복제가능(안정성)
- 업무 도메인별 메시지 분리가능.  
활용방안1:트랜젝션처리 플럼(대규모 실시간로그) --비동기---> 카프카(버퍼링- 트랜젝션1~N) -> 실시간 처리/분석
                                                                                              알림/ 적재 활용. 
활용방안2:장애극복 실시간 로그발생 -> 플럼 -> Hbase   
: 카프카가 없으면. Hbase 셧다운 or 네트워크 1차 장애...  플럼은 버퍼링이 크지않음. 2차장애
스마트카 실시간로그 -> 플럼 -> 카프카 브로커 1~3(대규모 분산임시저장소)-> 스톰-> Hbase

카프카 : 멀티노드, 대규모 클러스터.... 장애발생 2시간동안... 담아둘수 있음
설치 1. CM Cluster1 콤보박스 > 서비스 추가. > kafka > 계속 > kafka Broker  _  Server02설치.  나머지 설치안함.  > 완료. 
2. 환경구성
kafka> 구성  Data Retention Time : 7일 >> 15분
3. 재시작. 
실행
1. 플럼 설정 : 
카프카 싱크  : 카프카로 전송하는 플럼 에이전트. 

프로듀서 콘솔 -> 카프카 Broker : SmartCar-Topic -> Consumer Console1
                                                                 -> Consumer Console2
실행
2. Topic생성. 
서버 02
$kafka-topics --create --zookeeper server02.hadoop.com:2181 --replication-factor 1 --partitions 1 --topic SmartCar-Topic

--replication-factor : 카프카 다중 Broker 만들고 전송한 데이터를 replication-factor 개수만큼 복제하게 되는데, 파일럿 프로젝트는 단일 카프카 브로커이므로 복제개수는 1개만 설정한다. 
--partitions : 옵션은 해당 Topic에 데이터들이 partitions의 개수만큼 분리 저장하게 된다. 
이역시 다중 Broker에서 쓰기/읽기 성능 향상을 위해 사용하는 옵션이다. 파일럿 환경에서는 1로만 설정한다. 

중략

3. Producer사용.  $kafka-console-producer --broker-list server02.hadoop.com:9092 -topic SmartCar-Topic



중략

4. Consumer -1 사용
$kafka-console-consumer --bootstrap-server server02.hadoop.com:9092 --topic SmartCar-Topic --partition 0 --from-beginning

--from-beginning 지금까지 못받은데이터 전부다 출력. 

중략


5. Consumer-2 사용 $kafka-console-consumer --bootstrap-server server02.hadoop.com:9092 --topic SmartCar-Topic --partition 0 --from-beginning

중략


프로듀서 생성시

수많은 컨수머들이 동시 처리 
   
   
   
   
   

 

728x90

Error1

현상 2021-05-25 22:16:06,356 ERROR org.apache.flume.lifecycle.LifecycleSupervisor: Unable to start EventDrivenSourceRunner: { source:Spool Directory source SmartCarInfo_SpoolSource: { spoolDir: /home/pilot-pjt/working/car-batch-log } } - Exception follows.
org.apache.flume.FlumeException: Unable to read and modify files in the spooling directory: /home/pilot-pjt/working/car-batch-log
        at org.apache.flume.client.avro.ReliableSpoolingFileEventReader.<init>(ReliableSpoolingFileEventReader.java:195)
        at org.apache.flume.client.avro.ReliableSpoolingFileEventReader.<init>(ReliableSpoolingFileEventReader.java:89)
        at org.apache.flume.client.avro.ReliableSpoolingFileEventReader$Builder.build(ReliableSpoolingFileEventReader.java:882)

해결 폴더 권한 수정

>> SpoolDir 작동할때 : 읽고 쓰는 권한이 필요. root를 사용하지 않음. 
cd /home/pilot-pjt/
chmod 777 -R  working/

Error2

현상 재기동후
환경설정도 문제없는데...  CPU 


2021-05-27 12:42:14,419 WARN org.apache.flume.source.SpoolDirectorySource: The channel is full, and cannot write data now. The source will try again after 250 milliseconds
2021-05-27 12:42:14,675 INFO org.apache.flume.client.avro.ReliableSpoolingFileEventReader: Last read was never committed - resetting mark position.
2021-05-27 12:43:11,456 INFO org.apache.flume.client.avro.ReliableSpoolingFileEventReader: Last read took us just up to a file boundary. Rolling to the next file, if there is one.
2021-05-27 12:43:11,457 ERROR org.apache.flume.source.SpoolDirectorySource: FATAL: Spool Directory source SmartCarInfo_SpoolSource: { spoolDir: /home/pilot-pjt/working/car-batch-log }: Uncaught exception in SpoolDirectorySource thread. Restart or reconfigure Flume to continue processing.
java.lang.IllegalStateException: File has been modified since being read: /home/pilot-pjt/working/car-batch-log/SmartCarStatusInfo_20160102.txt


해결 파일이.. 다 생성되기 전에. 옮기니까 발생... 

 

 


플럼 flume.apache.org
: 원천데이터 수집(파일, DB, API) -> 플럼-> 하둡 적재
                                        Source    Sink
라이센스 Apache 2.0
유사 프로젝트 Fluented, Scribe, logstash, Chukwa, NiFI, Embulk 
주요
구성요소
****Source 다양한 원천 시스템의 데이터 수집위해  Avro, Thrift, JMS, Spool Dir , Kafka, 등 여러 컴포넌트 제공, 수집한 데이터 Channel로 전달
****Sink 수집한 데이터를 Channel로 부터 전달받아 최종 목적지에 저장하기 위한 기능으로 HDFS, Hive, Logger, Avro, ElasticSearch Thrift등을 제공. 
***Channel Source와 Sink를 연결 데이터를 버퍼링하는 컴포넌트로 메모리,파일, 데이터베이스 채널 의 저장소로 활용. 
Interceptor Source와 Channel사이에 데이터 필터링 및 가공하는 컴포넌트로서 Timestamp, Host, Regex, Filttering 등을 기본 제공하며, 필요 시 사용자 정의 Interceptor 추가. 
Agent Source-> (Interceptor) -> Channel-> Sink 컴포넌트 순으로 구성된 작업 단위, 독립된 인스턴스로 생. 
아키텍처 유형1 Agent (Source -> Channel -> Sink )
아키텍처 유형2 Agent
(Source -> Channel -> Sink : DB
Source -> Interceptor -> Channel -> Sink : 하둡
                                             -> Sink : DB )
아키텍처 유형3
병렬처리
(라우팅 이용)
플럼 에이전트1(Source -> Channel -> Sink) ->플럼에이전트2( Source ->Channel-> Sink):하둡
                                                          ->플럼에이전트3(Source-> Channel-> Sink): DB
아키텍처 유형4
(티어1 대규모데이터
티어 2 비지니스로직)
플럼
활용
장시간 수집 3초 간격 발생 - 대용량파일100MB/1일: 일단위수집-> 플럼에이전트 -> 장기수집 배치분석
발생 시
동시수집
1초 간격밸상 - 신시간 로그 499KB/1초: 실시간수집-> 플럼에이전트-> 실시간 분석
: 실시간 정보로 가치가 높을때만. 

** 실제 스마트카 안에 프럼이 설치..
설치 1. CM의 홈에서 Cluster1 콤보박스 [서비스 추가: add Service] > 추가할 서비스 유형 Flume 선택, 우측하단 계속버튼
> Agent > 설치 서버 호스트 server02.hadoop.com.. 확인> 계속.> 완료. 
2. 힙메모리 올리기
CM홈 > Flume >구성 > java heap  : 50 -> 100
3. Flume 재시작 
에이전트 생성 수정전 # Please paste flume.conf here. Example:

# Sources, channels, and sinks are defined per
# agent name, in this case 'tier1'.
tier1.sources  = source1
tier1.channels = channel1
tier1.sinks    = sink1

# For each source, channel, and sink, set
# standard properties.
tier1.sources.source1.type     = netcat
tier1.sources.source1.bind     = 127.0.0.1
tier1.sources.source1.port     = 9999
tier1.sources.source1.channels = channel1
tier1.channels.channel1.type   = memory
tier1.sinks.sink1.type         = logger
tier1.sinks.sink1.channel      = channel1

# Other properties are specific to each type of
# source, channel, or sink. In this case, we
# specify the capacity of the memory channel.
tier1.channels.channel1.capacity = 100
플럼 수집기능
플럼 > 구성

-에이전트 생성 1
시스템 그룹 Flume(서비스전체 : Service-Wide) : flume
Agent 이름 Agent Default Group : SmartCar_Agent
구성파일  Agent Default Group
:
SmartCar_Agent.sources  = SmartCarInfo_SpoolSource
SmartCar_Agent.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks    = SmartCarInfo_LoggerSink 

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.type = spooldir
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.spoolDir = /home/pilot-pjt/working/car-batch-log
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.deletePolicy = immediate
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.batchSize = 1000


SmartCar_Agent.channels.SmartCarInfo_Channel.type = memory
SmartCar_Agent.channels.SmartCarInfo_Channel.capacity  = 100000
SmartCar_Agent.channels.SmartCarInfo_Channel.transactionCapacity  = 10000


SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.type = logger

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.channel = SmartCarInfo_Channel

-에이전트 생성 2
SmartCar_Agent.sources  = SmartCarInfo_SpoolSource
SmartCar_Agent.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks    = SmartCarInfo_LoggerSink 

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.type = spooldir
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.spoolDir = /home/pilot-pjt/working/car-batch-log
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.deletePolicy = immediate
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.batchSize = 1000

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors = filterInterceptor

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.type = regex_filter
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.regex = ^\\d{14}
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.excludeEvents = false


SmartCar_Agent.channels.SmartCarInfo_Channel.type = memory
SmartCar_Agent.channels.SmartCarInfo_Channel.capacity  = 100000
SmartCar_Agent.channels.SmartCarInfo_Channel.transactionCapacity  = 10000


SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.type = logger

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.channel = SmartCarInfo_Channel
-드라이브카. 
구성파일  Agent Default Group
:
SmartCar_Agent.sources  = SmartCarInfo_SpoolSource DriverCarInfo_TailSource
SmartCar_Agent.channels = SmartCarInfo_Channel DriverCarInfo_Channel
SmartCar_Agent.sinks    = SmartCarInfo_LoggerSink DriverCarInfo_KafkaSink

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.type = spooldir
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.spoolDir = /home/pilot-pjt/working /car-batch-log
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.deletePolicy = immediate
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.batchSize = 1000

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors = filterInterceptor

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.type = regex_filter
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.regex = ^\\d{14}
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.excludeEvents = false


SmartCar_Agent.channels.SmartCarInfo_Channel.type = memory
SmartCar_Agent.channels.SmartCarInfo_Channel.capacity  = 100000
SmartCar_Agent.channels.SmartCarInfo_Channel.transactionCapacity  = 10000


SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.type = logger

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.channel = SmartCarInfo_Channel
    SmartCar_Agent.sources  = SmartCarInfo_SpoolSource DriverCarInfo_TailSource
SmartCar_Agent.channels = SmartCarInfo_Channel DriverCarInfo_Channel
SmartCar_Agent.sinks    = SmartCarInfo_LoggerSink DriverCarInfo_KafkaSink

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.type = spooldir
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.spoolDir = /home/pilot-pjt/working/car-batch-log
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.deletePolicy = immediate
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.batchSize = 1000

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors = filterInterceptor

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.type = regex_filter
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.regex = ^\\d{14}
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.excludeEvents = false


SmartCar_Agent.channels.SmartCarInfo_Channel.type = memory
SmartCar_Agent.channels.SmartCarInfo_Channel.capacity  = 100000
SmartCar_Agent.channels.SmartCarInfo_Channel.transactionCapacity  = 10000


SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.type = logger

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.channel = SmartCarInfo_Channel



SmartCar_Agent.sources.DriverCarInfo_TailSource.type = exec
SmartCar_Agent.sources.DriverCarInfo_TailSource.command = tail -F /home/pilot-pjt/working/driver-realtime-log/SmartCarDriverInfo.log
SmartCar_Agent.sources.DriverCarInfo_TailSource.restart = true
SmartCar_Agent.sources.DriverCarInfo_TailSource.batchSize = 1000

SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors = filterInterceptor2

SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.type = regex_filter
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.regex = ^\\d{14}
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.excludeEvents = false

SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.type = org.apache.flume.sink.kafka.KafkaSink
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.topic = SmartCar-Topic
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.brokerList = server02.hadoop.com:9092
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.requiredAcks = 1
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.batchSize = 1000


SmartCar_Agent.channels.DriverCarInfo_Channel.type = memory
SmartCar_Agent.channels.DriverCarInfo_Channel.capacity= 100000
SmartCar_Agent.channels.DriverCarInfo_Channel.transactionCapacity = 10000


SmartCar_Agent.sources.DriverCarInfo_TailSource.channels = DriverCarInfo_Channel
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.channel = DriverCarInfo_Channel
     
     
     
     
     
     
     

 

728x90
프로젝트 단계 1. 빅데이터 이해하기
2. 빅데이터 파일럿 프로젝트
3. 빅데이터 수집
4. 빅데이터 적재 1 : 대용량 로그파일 적재
5. 빅데이터 적재 2 : 실시간 로그/분석 적재
6. 빅데이터 탐색
7. 빅데이터 분석
8. 분석환경 확장. 
빅데이터 수집 1. 빅데이터 수집 개요
- 빅데이터 수집개념 중요성 , 일반 수집과 차이점 설명  >> 분산환경
2. 빅데이터 수집에 활용되는 기술
- 빅데이터 수집에서 사용할 두가지 기술(플럼, 카프카)를 소개하고 기술별 주요 기능과 아키텍쳐, 활용방안 알아본다. 
3. 수집, 파일럿 실행 1단계 -수집 아키텍처
- 스마트카에서 발생하는 로그파일 수집과 관련된 요구사항 구체화, 수집 요구사항을 해결하기 위한 파일럿 아키텍쳐를 이해한다. 
4. 수집 파일럿 실행 2단계 - 수집 환경구성
- 스마트카 로그 파일을 수집하기 위한 아키텍처 설치 및 환경구성을 진행한다. 플럼 카프카 순으로 설치를 진행한다. 
5. 수집 파일럿 실행 3단계 - 플럼 수집 기능구현
- 스마트카 로그 파일을 수집하기 위한 플럼 환경을 구성하고 관련 에이전트를 생성한다. 
6. 수집 파일럿 실행 4단계 - 카프카 수집 기능 구현
- 플럼이 수집한 데이터를 카프카 토픽에 전송하는 기능을 구현하고, 카프카의 토픽에 전송된 데이터를 확인하는 방법을 알아본다. 
7. 수집 파일럿 실행 5단계 - 수집 기능 테스트
- 로그 시뮬레이터가 생성한 스마트카의 상태정보 데이터를 플럼이 수집해서 카프카의 토픽에 전송하는 기능을 점검하고 전송된 데이터를 확인한다. 
수집 개요 수집 -> 적재 -> (처리/탐색 -> 분석/응용)  : 전체리소스 40~50%

내부데이터  ---정형--->  빅데이터 수집  <---비정형---- 외부데이터

비정형 : 스키마 정보 없이..텍스트 데이터 ex) SNS, 포털/블로그 
반정형 : CSV ex) 뉴스/날씨 기관 지표

내부데이터: 고객정보(RDB) , 거래정보(FTP), 상품/서비스정보(API), 마케팅/VOC(fIle)
외부데이터: SNS(API), 포털/블로그(크롤링), 뉴스/날씨(RSS), 기관, 지표(FTP)

내부데이터 효과 : 스마트카 이상징후 예측, 운전패턴 군집, 차량용품 추천
외부데이터 효과 : 운전자 성향, 평판분석, 사용자 프로파일 관심사 동향분석, 날씨 교통정보 차량 최적화
                       운전자의 관심, 뉴스를 음성 서비스로 제공
수집절차 수집 대상선정 (-> 수집계획 수립 -> 수집 실행)

수집 대상선정 : 도메인, 데이터셋 도출, 리스트 작성, 대상 부서 파악

수집 계획 수립 : 데이터 제공여부 협의 , 유형/속성 확인, 수집환경/표준 파악, 주기/ 용량 파악
                      수집 연동/포맷 파악, 수집 기술 선정, 수집 정의서/계획서 작성
                        **** 수집 정의서 : I/F 정의서 -> 개발. 
  
수집 실행 : 단위테스트 진행, 연동 테스트 진행, 데이터 수집 실행, 데이터 적재 처리. 
수집이 먼저?
분석 활용이 먼저?
정보없이 데이터만 가질수 있다.   
하지만 데이터 없이 정보를 가질 수 없다. 
- 대이얼 키즈 모란. 

~~ 분석없이 수집할수 있다. .. 무엇을 분석할지모르면서 무엇을 수집?
~~무엇을 분석할지 알고 있다면.. 빅데이터 시스템 필요 없다. .. 기존시스템 활용. 
기존 한계를 뛰어 넘기위한 시스템. >> 데이터로부터 새로운 발견이 목표. 
3V + 분석가 노하우.  데이터 패턴. .. 기존에 없었떤 데이터 패턴까지 볼수 있어 새로운 인사이트. 

ROI : Return on investment 투자 대비 수익이 나지 않아 실행하지 않았음. 
외부데이터 의 양이 너무 많아서.. RDBMS 한계 , 빅데이터 기술.  x86 저비용 고사양하드웨어로 가능해짐
수집 - 이키텍처
수집 요구사항 1. 차량의 다양한 장치로 발생하는 로그 파일을 수집해서 기능별 상태를 점검
2. 운전자의 운행정보가 담긴 로그를 실시간으로 수집해서 주행 패턴을 분석. 
수집 요구사항 구체화  1. 스마트카로부터 로그 파일들이 주기적으로 발생 : 플럼 이용 대용량 배치파일 실시간 로그파일수집
2. 스마트카 배치 로그 파일 이벤트 감지 : 플럼의 Source 컴포넌트중 SpoolDir이용  주기적인 로그파일 발생 이벤트 감지
3. 스마트카 실시간 로그발생이벤트 감지 > Source 컴포넌트중 Exec-Tail 을 이용 특정 로그 파일 로그생성이벤트 감지. 
4. 스마트 카에서 만들어내는 로그 데이터에 가비지데이터 있을 수 있다. >> 플럼의 Interceptor를 이용해 정상 패턴의 데이터만 필터링
5. 수집 도중 장애가 발생해도 데이터를 안전하게 보관및 재처리 할수 있다.>> 플럼의 메모리 Channel 카프카Broker 사용으로 로컬 디스크 파일 시스템에 수집 데이터를 임시저장
6. 스마트카의 실시간 로그 파일은 비동기 처리로 빠른 수집 처리를 해야한다. >> 플럼에서 수집한 데이터를 카프카 Sink 컴포넌트를 이용해 카프카 Topic에 비동기 전송. 
1단계 : 
플럼에이전트 1,2로 사용하는 방식. 
[3초간격발생] 
1. 차량상태정보 100MB/1일 
-------플럼에이전트1--------
2. SoolDir Source
3. Memory Channel
4. Logger Sink
---------플럼 Stdout--------
5. Log 파일                   >>>>>최종 하둡.....???
~~~~~~~~~~~~~~~~~~~~
[1초간격으로 발생]
6. 운전자운행정보 400KB/1초
--------프럶에이전트 2-------
7. Exec Tail Source
8. Memory Channel
9. Kafka Sink
----------카프카-----------
10. Topic
수집 기능 테스트 : 서버 2
1. 스마트카 로그
시뮬레이터 백그라운드 방식으로 실행. 

cd /home/pilot-pjt/working
(bigdata.smartcar.loggen-1.0.jar >> 로그시뮬레이터. )


## 일간. 
java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.CarLogMain 20160101 3 &

## 실시간. 
java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.DriverLogMain 20160101 3 &


tail -f /home/pilot-pjt/working/SmartCar/SmartCarStatusInfo_20160101.txt
tail -f /home/pilot-pjt/working/driver-realtime-log/SmartCarDriverInfo.log
2. 일간 로그파일을 
플럼 SmartCarInfo 에이전트의 SpoolDir 경로로 옮긴다. 
$mv /home/pilot-pjt/working/SmartCar/SmartCarStatusInfo_20160101.txt /home/pilot-pjt/working/car-batch-log/

$cd /home/pilot-pjt/working/car-batch-log/
$ls -ltr
3. 카프카 Topic생성
카프카 프로듀서 실행. (?? 별도인지 한번만실행인지 모르겠네용. )
$kafka-topics --create --zookeeper server02.hadoop.com:2181 --replication-factor 1 --partitions 1 --topic SmartCar-Topic

$kafka-console-producer --broker-list server02.hadoop.com:9092 -topic SmartCar-Topic
4. 플럼 설정 후 재시작 플럼 > 구성 
시스템 그룹 Flume(서비스전체 : Service-Wide) : flume

Agent 이름 Agent Default Group : SmartCar_Agent
구성파일  Agent Default Group
:
SmartCar_Agent.sources  = SmartCarInfo_SpoolSource DriverCarInfo_TailSource
SmartCar_Agent.channels = SmartCarInfo_Channel DriverCarInfo_Channel
SmartCar_Agent.sinks    = SmartCarInfo_LoggerSink DriverCarInfo_KafkaSink

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.type = spooldir
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.spoolDir = /home/pilot-pjt/working/car-batch-log
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.deletePolicy = immediate
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.batchSize = 1000

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors = filterInterceptor

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.type = regex_filter
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.regex = ^\\d{14}
SmartCar_Agent.sources.SmartCarInfo_SpoolSource.interceptors.filterInterceptor.excludeEvents = false


SmartCar_Agent.channels.SmartCarInfo_Channel.type = memory
SmartCar_Agent.channels.SmartCarInfo_Channel.capacity  = 100000
SmartCar_Agent.channels.SmartCarInfo_Channel.transactionCapacity  = 10000


SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.type = logger

SmartCar_Agent.sources.SmartCarInfo_SpoolSource.channels = SmartCarInfo_Channel
SmartCar_Agent.sinks.SmartCarInfo_LoggerSink.channel = SmartCarInfo_Channel



SmartCar_Agent.sources.DriverCarInfo_TailSource.type = exec
SmartCar_Agent.sources.DriverCarInfo_TailSource.command = tail -F /home/pilot-pjt/working/driver-realtime-log/SmartCarDriverInfo.log
SmartCar_Agent.sources.DriverCarInfo_TailSource.restart = true
SmartCar_Agent.sources.DriverCarInfo_TailSource.batchSize = 1000

SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors = filterInterceptor2

SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.type = regex_filter
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.regex = ^\\d{14}
SmartCar_Agent.sources.DriverCarInfo_TailSource.interceptors.filterInterceptor2.excludeEvents = false

SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.type = org.apache.flume.sink.kafka.KafkaSink
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.topic = SmartCar-Topic
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.brokerList = server02.hadoop.com:9092
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.requiredAcks = 1
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.batchSize = 1000


SmartCar_Agent.channels.DriverCarInfo_Channel.type = memory
SmartCar_Agent.channels.DriverCarInfo_Channel.capacity= 100000
SmartCar_Agent.channels.DriverCarInfo_Channel.transactionCapacity = 10000


SmartCar_Agent.sources.DriverCarInfo_TailSource.channels = DriverCarInfo_Channel
SmartCar_Agent.sinks.DriverCarInfo_KafkaSink.channel = DriverCarInfo_Channel
5. 카프카.
Counsumer작동
$kafka-console-consumer --bootstrap-server server02.hadoop.com:9092 --topic SmartCar-Topic --partition 0 --from-beginning

플럼 실시간에이전트 -> 카프카 전송  -> 카프카 브로커 스마트카 토픽 메시지 담겨있음. 
카프카 콘솔 컨슈머가 꺼내서 보내줌.  
  
수집 기능 점검
1. 플럼 표준출력로그 전송됐는지 확인 $tail -f /var/log/flume-ng/flume-cmf-flume-AGENT-server02.hadoop.com.log

agent 로그 확인가능. 수집되고 있는 헤더바디...




2021-05-25 22:16:06,356 ERROR org.apache.flume.lifecycle.LifecycleSupervisor: Unable to start EventDrivenSourceRunner: { source:Spool Directory source SmartCarInfo_SpoolSource: { spoolDir: /home/pilot-pjt/working/car-batch-log } } - Exception follows.
org.apache.flume.FlumeException: Unable to read and modify files in the spooling directory: /home/pilot-pjt/working/car-batch-log
        at org.apache.flume.client.avro.ReliableSpoolingFileEventReader.<init>(ReliableSpoolingFileEventReader.java:195)
        at org.apache.flume.client.avro.ReliableSpoolingFileEventReader.<init>(ReliableSpoolingFileEventReader.java:89)
        at org.apache.flume.client.avro.ReliableSpoolingFileEventReader$Builder.build(ReliableSpoolingFileEventReader.java:882)

>> SpoolDir 작동할때 : 읽고 쓰는 권한이 필요. root를 사용하지 않음. 
cd /home/pilot-pjt/
chmod 777 -R  working/

2. Consumer 콘솔창 수집되고 있는지 확인
테스트종료후 ps -ef |grep smartcar.log

CarLogMain, DriverLogMain 

kill -9 pid
파일럿 환경의 로그 확인 Hadoop에코시스템서버들 로그위치
/var/log/디렉터리(cloudera, Hadoop, Oozie, 등_)

Radis 서버 로그 위치 
/var/log/radis_6379.log

Storm 서버로그 위치 
/home/pilot-pjt/storm/logs/

Zeppelin 서버 로그 위치
/home/pilot-pjt/zeppelin-0.8.2-bin-all/logs
파일럿 환경에서
HDFS문제발생
HDFS 상에 Corrupt, Blockes/Files 같은 문제가 발생하거나 Safe 모드로 전환되어
빠져 못빠져나오는 경우 발생, 만약 파일럿 환경 일부 기능, 설치중 문제발생한다면 
HDFS 파일/불록 깨짐, 또는 Safe모드 전환 여부를 체크해야 한다. 

-HDFS 파일 시스템 검사 : $ hdfs fsck /
-HDFS Safe 모드 발생 후 빠져나오지 못 할 경우. 
  Safe 모드 강제 해제 : $hdfs dfsadmin -safemode leave
-HDFS Corrupt Blocks/Files 등이 발생해 복구가 불가능한 경우. 
  손상된 파일 강제 삭제 : $hdfs fsck / -delete                          >>하이브.. 등등 에코시스템영향. 
  손상된 파일을 /lost+found 디렉터리 이동 : $hdfs fsck / -move


728x90
하둡명령어
파일 HDFS의 /tmp 디렉터리로 저장  $hdfs dfs -put Sample.txt /tmp   
hdfs에 저장한 목록 확인 $hdfs dfs -ls /tmp
저장파일 내용보기 $hdfs dfs -cat /tmp/Sample.txt
hdfs파일상태보기  -파일크기 %b 파일블록크기 %o 복제수%r 소유자명%u 파일명%n
$hdfs dfs -stat '%b %o %r %u %n' /tmp/Sample.txt
hdfs저장한 파일 이름 바꾸기. $hdfs dfs -mv /tmp/Sample.txt /tmp/Sample2.txt
hdfs파일 로컬파일시스템가져오기 $hdfs dfs -get /tmp/Sample2.txt /home/bigdata/
hdfs파일삭제 - 휴지통에 임시 삭제된 파일 24시간 동안 유지후 자동삭제
$hdfs dfs -rm /tmp/Sample2.txt

- 완전삭제
$hdfs dfs -rm -skipTrash /tmp/Sample2.txt

파일시스템 상태검사 전체크기, 디렉터리수, 파일수, 노트수 _파일시스템 전체상태
$hdfs fsck /


TIP . HDFS 파일의 비정상 상태
"CORRUPT FILES", "MISSING BLOCKS", "MISSING SIZE", "CORRUPT BLOCKS" 등의 항목에 숫자표시. 
이 상태가 지속되면 HBase 하이브 등에 부분적 장애 발생 가능성. 
강제 셧다운 빈번하고 리소스 부족한 테스트 환경에서 자주 발생할 수 있는현상이다. 
원래 HDFS 비정상적인 파일 블록을 발견할 경우 다른 노드에 복구하려고 시도하며, 다음과 같이 사용자가 직접 삭제/이동 명령으로 조치할수 있다. 
CORRUPT : 오염된. 

강제로 안전모드 해제 $hdfs dfsadmin -safemode leave
손상된파일 강제 삭제 깨진블록 자동으로 복구... 만약 전부.. 문제있으면 강제 삭제. 
$hdfs fsck / -delete
손상된 파일을 /lost +found 디렉터리로 옮긴다. $hdfs fsck / -move
하둡 파일시스템 기본 정보 통계 $hdfs dfsadmin -report



주키퍼 명령어
zookeeper -client 실행 $zookeeper-client
생성 $create /pilot-pjt bigdata

보기 $ls /


가져오기 $get /pilot-pjt


지우기 $delete \pilot-pjt

   
   

 

728x90
빅데이터 클러스터 데이터를 클러스터링한다는 것은 연속적으로 액세스하는 데이터를 밀접하게 함께 저장하여 입출력 작업을 적게 하는 것을 의미한다
하나의 데이터를 여러개의 부분집합으로 분할하는것. 

SQL서버 내용중..
데이터 가상화 : 빅데이터 클러스터 SQL서버에서 데이터를 이동복사 하지 않고  외부데이터 원본 쿼리 가능. 
데이터 레이크 : 가공되지 않은 상태로 저장되어 접근이 가능한 엄청난 양의 데이터 
빅데이터를 빅데이터 클러스터의 HDFS 저장후 데이터를 분석 및 쿼리하고 관계형 데이터 베이스와 결합가능. 
스케일 아웃 데이터 마트 : 규모 확장계산 , 저장소 제공, 데이터 분석기능 향상. 
추가 분석을 위해 다양한 원본 데이터 수집 데이터 풀 노드간에 캐시로 분산. 
인공지능 및 머신러닝 : 스토리지, 데이터 풀에 저장된 데이터에서 통합 인공지능 및 머신러닝작업을 사용하도록 설정한다. 뿐만 아니라 자바 R 사용 SQL서버 기본제공 AI 도구 , 스파크 사용가능. 
관리 모니터링 

http://wiki.hash.kr/index.php/%EB%8D%B0%EC%9D%B4%ED%84%B0_%ED%81%B4%EB%9F%AC%EC%8A%A4%ED%84%B0
https://docs.microsoft.com/ko-kr/sql/big-data-cluster/big-data-cluster-overview?view=sql-server-ver15 >>> 무슨소리인지..
Cloudera Manager http://server01.hadoop.com:7180/ 접속
welcome
> cluster  Basics > Specify Hosts > Select Repository > Install Parcels > Inspect Cluster
Select Repository
- CDH
- Parcel
- ACCUMULO
- SQOOP

-ETL
-CLI
CDH 6.3.2.1. 설치 추가Pacel 전부 설치안함. 

CDH  : Cloudera's Distribution, including Apache Hadoop : 클라우데라의 하둡 배포판. 
추가 Parcel :클라우데라 메니저의 패키지. .. 
ACCUMULO: 아파치 아큐물로 :  분산 키-값 저장소
KAFKA: 아파치 카프카 : 분산 스트리밍 플래폼. 대량처리 분산 메시징 시스템 . 
SQOOP: 아파치 스쿱
: 관계형DB 하둡간 데이터 전송 CLI애플리케이션,
DBMS데이터를 HDFS로 입출력. 
하둡용 ETL 도구. 
하둡 기반 시스템 연동가능, Hive, HBase로 테이블 이전가능. 

대용량 병렬처리 데이터베이스
: EMC GreenPlum
HP Vertica
IBM Netezza
테라데이터의 KickFire.

- ETL : Extract, Transform load  , 추출 변환 로드. 
- CLI : Common Language Infrastructure : 공통언어기반. . 언어종속적이지 않은 플랫폼. 
Inspect Cluster I understand the risks, let me continue with cluster setup. 체크. 컨티뉴. 
add Cluster-configuration select Services, Assign Roles, Setup Database, Review Changes, Command Details Summary
select Services

-HDFS
-YARN
-MR2
-ZooKeeper
서비스(소프트웨어) 선택 :
사용자 지정서비스 선택> HDFS, 얀, 주키퍼, . 

HDFS : 아파치 하둡 분산 파일 시스템, 하둡의 가장우선되는 저장시스템
Apache Hadoop Distributed File System (HDFS) is the primary storage system used by Hadoop applications. HDFS creates multiple replicas of data blocks and distributes them on compute hosts throughout a cluster to enable reliable, extremely rapid computations.

YARN (MR2 Included)
: 아파치 하둡 맵리듀스, 얀 은 데이터 계산 프레임워크
(얀 리소스메니저 서버 자원관리 리소스 메니지먼트. CPU 메모리자원관리) 
Apache Hadoop MapReduce 2.0 (MRv2), or YARN, is a data computation framework that supports MapReduce applications (requires HDFS).

ZooKeeper: 중앙집중식 서비스, 환경 데이터를 유지, 동기화
Apache ZooKeeper is a centralized service for maintaining and synchronizing configuration data.
Assign Roles 어떤서버에 설치할지. 설정. 
HDFS : 
NN : NameNode : Server01 선택
SNN : SecondaryNameNode: Server01선택
B : Balancer : Server01 선택
HttpFS : 미설치
NFS Gateway : 미설치
DataNode: Server02

AP
ES
HM
SM

YARN
RM : ResourceManger : Server01
JHS : JobHistory: Server01
NodeManager : DataNode로 저장. 선택.   Same As DataNode

ZooKeeper
Server : Server02
설치완료후.  Cluster1 
색 임계치값  빨강 : 정지... 그외는 크게 문제 없음... ex)디스크 여유공간 10% 이하. 

자원이 부족할때 클라우데라메니저 중지. 해도 됨. 서비스기능에는 영향없음. 모니터링안됨. 
ssh 연결.  192.168.56.101 22 Server-1
192.168.56.102 22 Server-2
DataNode 추가 데이터노드는 파일시스템의 실질적인 일꾼이다. 데이터노드는 클라이언트나 네임노드의 요청이 있을 때 블록을 저장하고 탐색하며, 저장하고 있는 블록의 목록을 주기적으로 네임노드에 보고한다.

네임노드(namenode): 파일시스템의 네임스페이스를 관리한다. 네임노드는 파일시스템 트리와 그 트리에 포함된 모든 파일과 디렉터리에 대한 메타데이터를 유지한다. 이 정보는 네임스페이스 이미지(namespace image)와 에디트 로그(edit log)라는 두 종류의 파일로 로컬 디스크에 영속적으로 저장된다. 네임노드는 또한 파일에 속한 모든 블록이 어느 데이터노드에 있는지 파악하고 있다. 하지만 블록의 위치 정보는 시스템이 시작할 때 모든 데이터노드로부터 받아서 재구성하기 때문에 디스크에 영속적으로 저장하지는 않는다. 

출처: https://brocess.tistory.com/190 [행복한디벨로퍼]


CM 홈 HDFS 메뉴 우측 콤보박스 클릭 역할인스턴스 추가. 
DataNode 서버 추가. 확인 , 선택하고 시작 .
>> 4개서버 DataNode  데이터를 저장하면 01,02,03,04.. 저장. . 
실습을 위한 환경변수 설정
HDFS 복제 계수 설정
리플리카셋. 
 메인 > HDFS > Configuration> Replication Factor dfs.replication   3-> 1 저장

하둡 기본 : 쓰리리플리카  디폴트 복제계수 3
복제이유
1) 서버 1개 장애되도 백업사용 문제없음. 
2) 각각에 서버가 나눠읽고 합치면..(병렬처리)성능향상. 

HDFS > 구성 > 복제계수.      서버 3개면 2, 2개면 1

사용자 200M 저장 ==> .. S1 128M저장... S2 or S3  72M. 저장됨.
                             ==> 하둡.  S1-> S2,S3 복제 , S2-> S1,S3 복제

** 복제 계수 증가로 분석 성능 향상
앞서 복제 계수를 줄이는 것과 반대로 하둡에 이미 저장돼 있는 특정파일에 대해 복제 계수를 강제로 증가시킬수 있다.  그러면 여러 데이터 노드에 복제 파일이 분산 저장되어 분석 작업 시 로컬리티와 병렬성을 높여 성능을 극대화 할수 있다. 
/user/hadoop
hadoop fs -setrep 10 -R /user/hadoop/
HDFS 접근 권한 해제 HDFS 권한 검사 : 해제
Check HDFS Permissions  _ dfs.permissions
HDFS 블록 크기 변경 HDFS 블록크기 변경 128 => 64
HDFS Block Size _ dfs.blocksize
YARN 스케줄러와 
리소스매니저의 메모리설정
YARN 스케줄러 메모리 변경 1-> 1.5
Container Memory Maximum  _ yarn.scheduler.maximum-allocation-mb

리소스매니저 메모리 변경 1-> 5
Container Memory _ yarn.nodemanager.resource.memory-mb

YARN 스케줄러 변경 Scheduler Class _ yarn.resourcemanager.scheduler.class


org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler
   :: 동시다발적으로 일을시키다... 경합...오버헤드 행걸리는현상..때문에...
->org.apache.hadoop.yarn.server.resourcemanager.scheduler.fifo.FifoScheduler
동시처리는 못함. 순차처리.. 됌. 
환경설정후.
배포구성아이콘 활성
변경설정시 활성화 . 아이콘 클릭후 변경. 
참고.  호스트 > 모든호스트 >  역할 부분클릭시 할당 확인가능. 
 
로그 시뮬레이터 설치  
   
   
하둡 명령어 사용. 


파일시스템 상태검사. _ 전체크기, 디렉터리수, 파일수, 노트수 _파일시스템 전체상태
$hdfs fsck /


하둡 파일시스템 기본 정보 통계
$hdfs dfsadmin -report




강제로 안전모드 해제
$hdfs dfsadmin -safemode leave

손상된파일 강제 삭제       깨진블록 자동으로 복구... 만약 전부.. 문제있으면 강제 삭제. 
$hdfs fsck / -delete

손상된 파일을 /lost +found 디렉터리로 옮긴다. ... 불안할때.. 옮기는중일수있어서. 
$hdfs fsck / -move

주키퍼 명령어.  zookeeper -client 실행
$zookeeper-client

$create /pilot-pjt bigdata
$ls /
$get /pilot-pjt
$delete \pilot-pjt

시뮬레이터  mkdir -p /home/pilot-pjt/working/car-batch-log
mkdir -p /home/pilot-pjt/working/driver-realtime-log
java -version
cd /usr/bin
# ls -l java
lrwxrwxrwx. 1 root root 22 Jun 30  2018 java -> /etc/alternatives/java
# pwd
/usr/bin
# rm java
rm: remove symbolic link `java'? y
# rm javac
rm: cannot remove `javac': No such file or directory
# ln -s /usr/java/jdk1.8.0_181-cloudera/bin/javac /usr/bin/javac
# ls -l javac
lrwxrwxrwx 1 root root 41 May 23 00:12 javac -> /usr/java/jdk1.8.0_181-cloudera/bin/javac
# ln -s /usr/java/jdk1.8.0_181-cloudera/bin/java java
# ls -l java
lrwxrwxrwx 1 root root 40 May 23 00:13 java -> /usr/java/jdk1.8.0_181-cloudera/bin/java
# java -version
java version "1.8.0_181"
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)


/home/pilot-pjt/working
bigdata.smartcar.loggen-1.0.jar 옮김

java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.DriverLogMain 20200901 10

java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.CarLogMain 20200901 10

새창

# cd /home/pilot-pjt/working/driver-realtime-log/
# ls -ltr
total 148
-rw-r--r-- 1 root root 147980 May 23 00:20 SmartCarDriverInfo.log
# tail -f SmartCarDriverInfo.log

ps -ef |grep DriverLogMain
kill -9 PID


시작
01 버추얼 박스 실행, 가상머신 관리자 창 활성화
02 서버 순서대로 시작
03 3개 가상머신 창 활성화 CentOS 구동
04 Putty Server01에 ssh 접속 cm 구동 완료되었는지 확인
 $service cloudera-scm-server status

05 크롬브라우저실행 CM 관리자 화면 접속
http://server01.hadoop.com:7180/cmf/login
06 CM  클러스터1 콤보박스 선택 재시작 클릭
. 주키퍼 > HDFS > YARN    의존관계.   CM 이 알아서 재기동해줌. 



빨갈때.. 디스크 임께치... 혹은... 등등.. 스스로 경고.. 여러번 시도함.. 보통 정상적으로 돌아옴
HDFS 에서 파일 깨지는 경우가 발생할때... 나머지 오작동... 하이브..얀들..
종료 01  클러스터 1 Stop 클릭.  , 클라우데라 관리 서비스 종료. 



02 server01~~ putty 로 접속 시스템 종료 명령
halt

03. 버추얼 박스의 가장 머신 목록에서  Server01~03 모두 전원끄기로 정료. 

04 버추얼박스 관리자 닫음. 
정리 1. 파일럿 프로젝트 도메인의 이해
- 파일럿 프로젝트의 기본 도메인을 이해하고, 이와 관련된 빅데이터 요구사항을 도출 분석
2. 빅데이터 파일럿 아키텍처 이해
- 스마트카의 빅데이터 분석을 위한 소프트웨어/하드웨어 아키택처를 이해한다. 
3. 빅데이터 파일럿 프로젝트용 PC 환경구성
- 파일럿 프로젝트 환경을 구성하기 위해 독자들의 PC에서 사용할 기본 소프트웨어를 설치하고 구성한다. 이과정에서 이클립스, 자바, 오라클 버추얼박스등 설치
4. 빅데이터 파일럿 프로젝트용 PC서버 구성. 
- 3개의 가상 머신을 생성하고 분산 클러스터 환경을 구성하기 위한 3대의 리눅스 서버를 설치 및 구성
5. cm설치
-빅데이터 소프트웨어들을 설치/관리하는 Cloudera Manager를 설치 한다. CM을 이용해 빅데이터 파일럿 프로젝트의 기본 소프트웨어인 하둡 주키퍼 설치
6. 스마트카 로그 시뮬레이터 설치
- 스마트카의 상태 정보와 운행정보를 시뮬레이션해 로그 데이터를 생성하는 자바 프로그램을 설치한다. 
7 파일럿 환경관리
- 파일럿 환경을 안전하게 시작하고 종료하는 방법을 설명한다. 
   

 

Parcel : 파셀. 소포, 구획 / 소포를 싸다. 

Extract : 익스트렉트 / 발췌, 초록, 추출물. 추출하다. 

NETEZZA 인디안언어. 결과

computation : 계산. 

replicas : 복제품. 

embedded  : 내장형. 

테스크 포스 : 사업 계획 달성 위해 별도로 설치하는 임시조직

 

교제 : https://github.com/wikibook/bigdata2nd

 

 

현상 :  

 You are running Cloudera Manager in non-production mode, which uses an embedded PostgreSQL database. Switch to using a supported external database before moving into production

클라우디아 메니져를  non-production  모드로 사용하고 있는데- 내장형 PostgresSQL 사용하는 

프로덕션 이동전에 외부데이터 사용으로 전환해주세요. 

 

해결 : 위와같은 경고 메세지를 비활성화 하는 방법은 아래와 같습니다.

클라우데라 매니져 "홈"  > 상단 "검색" 버튼 클릭 > "postgresql" 입력 > 엔터 > "Enable Embedded Database Check" 해제

출처 : https://www.inflearn.com/questions/218026

 

 

728x90

https://blog.1028web.com/entry/virtualbox  에 연결된글입니다. 

 

[1028 virtualbox] 버추얼박스와 네트워크 _ NAT, 라우터, 게이트웨이

1. VirtualBox-6.1.22-144080-Win.exe 설치 2. 파일> 환경설정> 네트워크 > NAT 네트워크 추가. 더보기 네트워크 이름 : NatNetwork 네트워크 CIDR(C) :10.0.2.0/24 네트워크 옵션: DHCP지원 3. 호스트전용네트워..

blog.1028web.com

1. CentOS 7 부팅시 콘솔모드로 변환 Application > System Tools > Terminal
$systemctl get-default
$systemctl set-default multi-user.target
$reboot
2. 이더넷 설정
고정IP 네트워크 설정. 
nmcli (NetworkManager Command Line Interface)
$nmcli d(evice)
ifcfg-enp0s3파일생성.
$vi /etc/sysconfig/network-scripts/ifcfg-enp0s3
수정
#BOOTPROTO="dhcp"

추가
BOOTPROTO=static                       ##고정아이피
IPADDR=192.168.56.101
NETMASK=255.255.255.0
GATEWAY=192.168.0.1
HWADDR=08:00:27:E3:CB:07          ##어댑터 2 맥주소. 


DNS1=192.168.56.1
DNS1=192.168.56.2

systemctl restart network 
ifconfig enp0s3

https://www.manualfactory.net/10004
3. /etc/udev/rules.d/70-persistent-net.rules  주석저리  삭제 혹은 주석처리. 
4, ssh접속. 위한설정 $yum install opens.sh*
$service sshd restart
$chkconfig sshd on      # 서버 부팅마다 실행설정
$reboot
리부트후
$systemctl restart network
5. host 설정 /etc/sysconfig/network
HOSTNAME=server01.hadoop.com
$systemctl restart network 
$hostname
6. 환경변수 설정.  상기.링크 복제 항목에 동일하게 있음. 
7. 가상머신 복제  Server01 가상서버 종료. 
우클릭 복제. 
Server02 변경, 완전한복제. 
상기 2~5번사항 수정. 
8. 쁘띠 셋팅  
빅데이터 인프라 설치 및 구성 VM을 미리 만들어 제공하기도함. 
인프라환경
Puppet 
Ansible
Chef

Ambari                : 호트노스 진영
Cloudera Manager : 클라우데라 진영  >>CM
BigTop
Cloudera Manager(CM)  수집 : 플럼,카프카, 스톰&에스퍼
적재: 하둡 HBase 레디스
처리/탐색: 하둡, 휴, 하이브 스파크, 우지, 스쿱
분석/응용 : 임팔라/제플린/머하웃. 

공통: 클라우데라 메니저: 상기 소프트웨어 설치& 관리& 모니터링

주요 기능
1. 프로비저닝 : 하둡에코시스템 편리하게 설치, 삭제, 수정관리
2. 매니지먼트 : 설치한 에코시스템의 설정 변경 및 최적화 지원
3. 모니터링 : 하드웨어의 리소스 및 설치 컴포넌트 상태의 모니터링/대시보드
클라우데라 메니저 설치 1. 파일받기
cd /root
wget https://archive.cloudera.com/cm6/6.3.1/redhat6/yum/cloudera-manager.repo
yum 레포지토리 경로 이동 
mv /root/cloudera-manager.repo .repo /etc/yum.repos.d/
2. CM데몬과 서버설치 , jdk1.8 설치
yum install oracle-j2sdk1.8
yum install cloudera-manager-daemons cloudera-manager-server
3. CM 내부 사용 DB 설치. PostgreSQL서치 서비스 시작
pg_hba.cof 파일 수정. .. 원격접속가능하도록. 
yum install cloudera-manager-server-db-2
service cloudera-scm-server-db start

vi /var/lib/cloudera-scm-server-db/data/pg_hba.conf
reject -> md5
host all all 0.0.0.0/0 trust  추가
클라우데라DB 리스타트
4. CM서버 시작상태확인. 
5. 파일럿 pc host 파일 -도메인서버 맵핑. 
6. 크롬브라우저로 구동 확인 로그인. 
하둡 배포판 클라우데라사 CDH, 호튼웍스사의 HDP
자체 배포판을 만듬. 

  http://server01.hadoop.com:7180/
admin/admin
계속버튼 > 하단 Cloudera Express 선택
>계속버튼 > 클러스터이름 :Cluster1
>계속버튼 > 현재관리되고 있는 호스트 탭.  서버 두개 선택 계속

가상머신 환경구성- 네트워크 설정  

 

inittab - 5-> 3하려고 하는데 위치가 변경됨. 

더보기

로그인후 x윈도화면이아니라 바꾸러 왔더니 ... 이니텝 안쓴다고...;;;;

multi-user.target

환경변수

더보기

 

SELINUX=disabled .. 수정.. 방화벽이 꺼져있어야 분산환경 정상작동. 

iptable,

ip6table,

swappiness=100 #메모리 스왑. .. 적극적으로 사용해야함. 

컴파일 설정. 

echo never > /sys/kernel/mm/transparent_hugepage/enable

echo never > /sys/kernel/mm/transparent_hugepage/defrag

 

 

  1. 익명 2022.06.21 07:53

    비밀댓글입니다

    • IM1028 2022.06.21 11:50 신고

      좋은 답을 드리고 싶었는데.ㅜㅜ 인프런에서 들었던 15일간의 빅데이터 파일럿 프로젝트 강의가 만료되었네요. 어렴풋한 기억에는 이전버전으로 설치했던걸로 기억합니다. ㅜㅜ

728x90

<소프트웨어>

 

1. 데이터 셋

- 스마트카 상태 정보 데이터셋  : 일단위

- 스마트카 운전자 운행 데이터셋 : 실시간

- 스마트카 마스터 데이터셋 : 운전자 프로파일(이름, 거주지,나이,성별)

- 스마트카 물품구매 이력 데이터셋: 쇼핑몰 구입한 차량 물품 구매목록. 데이터셋. 

 

수집레이어

원천데이터: 스마트카 운영, 상태, 마스터

수집영역 : 플럼 -> 카프카-> 스톰/에스퍼 

적재영역 :        -> 하둡                   └> HBase, 레디스

 

적재레이어

수집영역    적재영역           처리/탐색영역

플럼       -> 하둡                 휴(하이브, 스파크, 우지, 스쿰)

스톰      -> HBase, 레디스                                      :이벤트 프로세싱

 

처리/탐색영역

적재영역      처리/탐색영역                           분석/응용 영역

하둡               휴

HBase            (하이브, 스파크, 우지 +스쿰)         임팔라, 제플릿, 머하웃. 

레디스

 

R/텐서플로 : 데이터 엑세스 해서 분석

머하웃/스파크  : 직접 워크로드만듬

임팔라/제플린 : 인메모리 빠른 탐색적 분석. 

 

빅데이터 기술 접근법

플랫폼 전문가 : 하둡 에코시스템 설치 및 구성

수집/적재 전문가 : 대규모 데이터 연동 및 통합

처리/탐색 전문가 : 데이터 모델 설계 및 처리. 

분석/응용 전문가 : 도메인 분석 및 인사이트 도출. 

 

2. 아키텍처 이해

소프트웨어/하드웨어 이해

3. PC 환경구성

자바, 이클립스, 오라클 버추얼박스

버추얼박스는 호환성문제때문에 가능하면 old 버전으로 5.0 사용. window host x86

4. 빅데이터 파일럿 프로젝트용 PC 서버 구성

3개 가상머신 생성, 분산 클러스터 환경 구성하기 위한 3대리눅스 서버 설치및 구성. 

5. CM : 클라우데라 메니저. : 빅데이타 소프트웨어 설치/관리 :: 하둡, 주키퍼. 

6. 스마트카 로그 시뮬레이터 설치. 

7. 파이럿 환경 관리. 

 

 

<하드웨어>

3V : Volume, Velocity, Variety : 크기, 속도, 다양성 : 얼마나 많은, 자주, 다양한 데이터가 발생하는가?

 

SSD.. 아니면... 병목현상

CPU 가상화. 가능한

고사향 1번, 2번, 3번 서버....

저사향 1번, 2번 ........................

Server1 Hadoop Management Nodes, Hadoop DataNodes, HBase Management, HBase Region Server, PostgresSql

Server2 Hadoop DataNode, HBase Region, 우지, 플럼, 레디스, 하이브/스파크, 스톰, 휴, 제플린, 키프카, 주키퍼

Server3 Hadoop DataNode, HBase Region, Cloudera Management, 임팔라, 스쿱 

CM 클라우데라 메니저. 

개발도구에서 각각 서버에 접속해서 빅데이터 AI작업진행. 

오라클 버추얼박스

OS Windows, mac OS/Linux

x86 데스크톱 PC

 

 

버추얼박스- 네트워크설정 파일> 환경설정> 네트워크 > NAT 네트워크 추가. 
네트워크 이름 : NatNetwork
네트워크 CIDR(C) :10.0.2.0/24
네트워크 옵션: DHCP지원
NATNetwork Address Translation Natwork Address Translation :  네트워크 주소 변환. 
IP 패킷에 있는 출발지 및 목적지의 IP 주소와 TCP/UDP 포트 숫자등을 바꿔 재기록하면서 네트워크 트래픽 주고받음

장점 :
1) 주소절약 : 하나의 공인 IP 주소 여러대 호스트가 인터넷접속 가능. 
인터넷공유기로 여러 PC 사용하는데 이게 NAT 기능, 부족한 공인IP 절약
2) 보안 : NAT 동작의 특성상 IP를 숨길수 있는 기능,
라우터 외부로 트래픽 나갈때 사설 IP 가 공인 IP 주소로 바뀌므로 공격자가 라우터 안쪽에 있는 사설 IP 몰라서 최종목적지 공격이 어려워 내부 네트워크 및 호스트 보호. 

프로세스:
1) 패킷해더에 출발지 목적지 주소 기록, 출발지는 자신의 사설 IP주소.
PC 출발
-출발지 10.0.0.1
-목적지 200.100.10.1

2) 기본 게이트 웨이에서 외부로 나가는 패킷을 인식하게되면
출발지IP 주소를 게이트웨이 자신의 공인IP 주소로 변경, 별도의 NAT 테이블 보관
- 출발지  10.0.0.1 -> 150.150.0.1 (재기록,변경)
- 목적지 200.100.10.1
NAT 테이블
프로토콜 | 사설IP   |  출발지IP    |   목적지 IP 
TCP        | 10.0.0.1 | 150.150.0.1 |   200.100.10.1

3) 웹서버에서 수신한 데이터 처리후 , 응답하여 보내는 패킷에 출발지와 목적지의 IP 주소를 아래와 같이 기록
호스트 설정 http://server01.hadoop.com:7180/

192.168.56.101 server01.hadoop.com 
192.168.56.102 server02.hadoop.com 
192.168.56.103 server03.hadoop.com 


아키텍쳐
메모리할당.  서버 메모리 할당.
시스템 > 마더보드 기본메모리 
Server01 3584
Server02 3072
크라우데라 에이전트 기본 패키지 설치 .   http://server01.hadoop.com:7180/
admin/admin
계속버튼 > 하단 Cloudera Express 선택
>계속버튼 > 클러스터이름 :Cluster1
>계속버튼 > 현재관리되고 있는 호스트 탭.  서버 세개 선택 계속

welcome> cluster  Basics > Specify Hosts > Select Repository > Install Parcels > Inspect Cluster
Oracle JDK 설치 선택
java 암호화 정책파일 선택안함. 
ssh 로그인 정보 제공. root adminuser
사용자 지정서비스 선택
I understand the risks, let me continue with cluster setup. 체크. 컨티뉴. 
1차 설치 
HDFS, YARN, Zookeeper
select Services> Assign Roles>  Setup Database> Review Changes> Command Details Summary

HDFS : 
NN : NameNode : Server01 선택
SNN : SecondaryNameNode: Server01선택
B : Balancer : Server01 선택
HttpFS : 미설치
NFS Gateway : 미설치
DataNode: Server02

YARN
RM : ResourceManger : Server01
JHS : JobHistory: Server01
NodeManager : DataNode로 저장. 선택.   Same As DataNode

ZooKeeper
Server : Server02

기본설정으로 저장 진행. 
완료 후 >> 색 임계치값  빨강 : 정지... 그외는 크게 문제 없음... ex)디스크 여유공간 10% 이하. 
자원이 부족할때 클라우데라메니저 중지. 해도 됨. 서비스기능에는 영향없음. 모니터링안됨. 

DataNode 추가. 
CM 홈 HDFS 메뉴 우측 콤보박스 클릭 역할인스턴스 추가. 
DataNode  데이터를 저장하면 01,02,저장. . 
DataNode 추가된거 확인하고선택, 선택된작업 콤보박스 시작 .



-- 환경변수. 
1. 
메인 > HDFS > Configuration> Replication Factor dfs.replication   3-> 1 저장

cf)
/user/hadoop

hadoop fs -setrep 10 -R /user/hadoop/

Check HDFS Permissions  _ dfs.permissions 해제

HDFS 블록크기 변경 128 => 64
HDFS Block Size _ dfs.blocksize
2. 
YARN 스케줄러 메모리 변경 1-> 1.5
Container Memory Maximum  _ yarn.scheduler.maximum-allocation-mb

리소스매니저 메모리 변경 1-> 5
Container Memory _ yarn.nodemanager.resource.memory-mb

Scheduler Class _ yarn.resourcemanager.scheduler.class
org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler
   :: 동시다발적으로 일을시키다... 경합...오버헤드 행걸리는현상..때문에...
->org.apache.hadoop.yarn.server.resourcemanager.scheduler.fifo.FifoScheduler
동시처리는 못함. 순차처리.. 됌. 

-- 동작확인. 
$cd /home/bigdata
$hdfs dfs -ls /tmp
$zookeeper-client > 2번서버

시뮬레이터 설치 mkdir -p /home/pilot-pjt/working/car-batch-log
mkdir -p /home/pilot-pjt/working/driver-realtime-log


1,2번서버
$java -version
$cd /usr/bin
$ ls -l java
lrwxrwxrwx. 1 root root 22 Jun 30  2018 java -> /etc/alternatives/java
$ pwd
/usr/bin
$ rm java
rm: remove symbolic link `java'? y
$ rm javac
rm: cannot remove `javac': No such file or directory
$ ln -s /usr/java/jdk1.8.0_181-cloudera/bin/javac /usr/bin/javac
$ ls -l javac
lrwxrwxrwx 1 root root 41 May 23 00:12 javac -> /usr/java/jdk1.8.0_181-cloudera/bin/javac
$ ln -s /usr/java/jdk1.8.0_181-cloudera/bin/java java
$ ls -l java
lrwxrwxrwx 1 root root 40 May 23 00:13 java -> /usr/java/jdk1.8.0_181-cloudera/bin/java
$ java -version
java version "1.8.0_181"
Java(TM) SE Runtime Environment (build 1.8.0_181-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.181-b13, mixed mode)


/home/pilot-pjt/working
bigdata.smartcar.loggen-1.0.jar 옮김

java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.DriverLogMain 20190101 3

java -cp bigdata.smartcar.loggen-1.0.jar com.wikibook.bigdata.smartcar.loggen.CarLogMain 20190901 10

새창

# cd /home/pilot-pjt/working/driver-realtime-log/
# ls -ltr
total 148
-rw-r--r-- 1 root root 147980 May 23 00:20 SmartCarDriverInfo.log
# tail -f SmartCarDriverInfo.log

ps -ef |grep smartcar.loggen
kill -9 PID
2차 설치 
플럼, 카프카
1. CM의 홈에서 Cluster1 콤보박스 [서비스 추가: add Service] > 추가할 서비스 유형 Flume 선택, 우측하단 계속버튼
> Agent > 설치 서버 호스트 server02.hadoop.com.. 확인> 계속.> 완료. 
2. 힙메모리 올리기
CM홈 > Flume >구성 > java heap  : 50 -> 100
3. Flume 재시작 

플럼> 구성
시스템 그룹 Flume(서비스전체 : Service-Wide) : flume
Agent 이름 Agent Default Group : SmartCar_Agent
구성파일  Agent Default Group
:


1. CM Cluster1 콤보박스 > 서비스 추가. > kafka > 계속 > kafka Broker  _  Server02설치.  나머지 설치안함.  > 완료. 
2. 환경구성
kafka> 구성  Data Retention Time : 7일 >> 15분
3. 재시작. 

$kafka-topics --create --zookeeper server02.hadoop.com:2181 --replication-factor 1 --partitions 1 --topic SmartCar-Topic

$kafka-console-producer --broker-list server02.hadoop.com:9092 -topic SmartCar-Topic

$kafka-console-consumer --bootstrap-server server02.hadoop.com:9092 --topic SmartCar-Topic --partition 0 --from-beginning

$kafka-console-consumer --bootstrap-server server02.hadoop.com:9092 --topic SmartCar-Topic --partition 0 --from-beginning
   
 

   
   

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  1. kgj 2021.08.24 17:40

    안녕하세요 빅데이터 관련 일을 시작하게된 코린입니다. 같은 책을 사서 실습을 해보려는데 초반부터 안되는 부분이 너무 많네요 혹시 질문 좀 드려도 될까요?

    • IM1028 2021.08.24 21:20 신고

      저도 중도하차했어요ㅋㅋ참고로 인프런강의 저자가하셔서 물어보면 잘대답해주세요.
      아는건 물어보심 답은드릴께요~^

728x90

<소프트웨어 아키텍처>

수집 : 플럼 , 카프카, 스톰

적재 : 하둡, HBase, 레디스                           - 업무시스템

처리/탐색 : 하둡, 휴(하이브/스파크, 우지, 수쿱) - 업무시스템 DB

분석/응용 : 임팔라, 제플린, 머하웃, R, 텐서플로 - 서비스 API Flask 

빅데이터 시작 모바일시대 > 빅데이타 시작> IOT.. 4차산업형명 : 인공지능, Iot, 사물인터넷...
과거 데이터 현상이해 미래예측... . 
일부문제 발생해도 영향 없으면 큰수의 법칙. .. 후속조치. 
6V 3V : 데이터 크기, 다양성, 속도 + 2V: 진실성, 시각화 = 1V 가치

빅데이터 레이크 & 웨어 하우스 : Volume, Variety, Velocity
빅데이터 마트 :상품/서비스+고객/마케팅+리스크관리 : Veracity
인사이트:현상이해 +현상발견+현상예측 : Visualization
비즈니스 : 비용절감+수익창출+문제해결 : value
데이터 목적  데이터 & 사람 & 기술. -> 인사이트 : 비용절감, 수익창출, 문제해결. 

빅데이터 인사이트

1. 현상이해 : 회원가입, 평균이용시간, 이용경로, 서비스 관심도, 상품및 휴면/해지율:  현황이해 
2. 현상발견 : 고객증가, 매출증가, VOC 원인은? 
3. 현상예측 : 모형을 만들어 예측 - 머신러닝, 딥러닝. 
빅데이터
vs  AI
빅데이터 시스템                                                     AI시스템
BI 데이터 마트 + AI 데이터 마트    ---학습데이터 -->    머신러닝   딥러닝
빅데이터 웨어하우스                                               AI 개발/학습
빅데이터 레이크 
빅데이터 활용 상품/서비스 : 상품/서비스 개발 및 개선에 활용
마케팅 지원 - 빅데이터를 대규모 고객 및 시장 분석에 활용
리스크 관리 - 빅데이터를 리스크 검출 밒 예측 분석에 활용. 
RDBMS , 
BigData 
RDBMS ,  BigData  : 상호 보완적. 
프로젝트 플랫폼 구축형 프로젝트
: 빅데이터 SI 구축형 사업 ,   수집-> 적재-> 처리-> 탐색-> 분석 기능구현, 3~10개월.  하드웨어 소프트웨어구성
: 프로젝트관리자-아키텍트 
      - 플랫폼파트(설치/구성) + 전처리파트(수집/적재) + 후처리 파트(처리 / 탐색 / 분석)
빅데이터 분석 프로젝트
      - 빅데이터 플랫폼 구축 완료후 수행, 빅데이터 탐색으로 데이터의 이해가 높아질때 시작. 
        조직의 가치사슬 중 대규모 분석이 필요한 시점에 추진, 1~3개월 일정으로 추진
         분석주제영역 - 마케팅/고객, 상품/서비스 개발, 리스크 관리 
    ***IT, 업무담당자 조율이 중요.  빠른성과 기대 위험. 데이터 양 탐색 단계적으로 높일 것. 
         조직도 - 빅데이터 분석 프로젝트 
         프로젝트 관리자 - 비즈니스 + 데이터 분석 + 데이터 엔지니어링 
빅데이터 운영프로젝트
        : 구축 완료된 플랫폼을 중장기적으로 유지관리
          대규모 하드웨어 /소프트웨어로 운영 비용높음
          빅데이터 분야별 전문가 그룹이 확보되어야 함. 
           빅데이터 거버넌스 체계를 수립해야함. : 전사시스템.. 여러부서 여러 담당자 ... 표준화, 역할 , 데이터 표준화 
구축단계  <전처리>
수집 : 내외부 데이터 연동
적재 : 대용량/실시간 데이터 처리, 분산 파일 시스템 저장 
처리 : 데이터 선택, 변환, 통합, 축소, 데이터 워크플로 및 자동화
<후처리>
탐색 : 대화영 데이터 질의, 탐색적Ad-Hoc 분석
분석 : 빅데이터 마트 구성, 퉁계분석 고급 분석
<활용>
응용 : 보고서 및 시각화 분석 정보 제공 
구축단계
수집 -> 적재 -> 처리/탐색 <->분석/응용
emerging market
: 급성장하는 시장. 
대용량 저장소, 대규모 배치처리
> 실시간 처리 온라인분석
> 전처리 및 분석 마트 고급분석 및 마이닝. 
빅데이터 기술 변화 인프라스트럭처        : HP, IBM, Cisco, Dell, RedHat
+ 소프트웨어 플랫폼 : Cloudera, MapR, KT넥스알, 그루터, 크라우디인 
+ IT서비스 : KTDS, LG CNS, 삼성SDS, SK C&C, 다음소프트

2014년 기준 점유율 :  Cloudera 51%, HortonWorks 33%,  MapR 테크놀로지스 16%
수집 수집- 정재, 변환, 필터링 -> 빅데이터저장
상 : 크기, 속도, 다양성
하 : 정확성, 시각화, 가치
적재 분산스토리지 영구/임시저장
HDFS : 대용량 영구저장  , 실시간X   :  하둡
No-sql,  카산드라 영구저장.            :  Hbase
레디스 웹캐시 : 임시저장.               : 레디스
MOM                                        : 카푸카

상: 크기, 속도, 진실성 
중 : 다양성                       ----트레이드 오프 주의
하 : 시각화 가치 
처리/탐색 - 탐색적 분석
- 탐색적분석 : sql하둡

상: 크기,  진실성, 시각화
중 : 가치                       ----트레이드 오프 주의
하 : 속도, 다양성 
분석/응용 -통찰력
데이터마이닝/머신러닝... 현재개선. 
빅데이터 분석기술로 찾아 알고리즘... 
선형적확장 가능... 
머신러닝 --- 군집, 분류, 회기,   
상 : 6v ; 크기, 속도, 다양성, 시각화, 정확성, 가치 
빅데이터와 보안 시스템보안
데이터 보안   ------
네트워크 보안
물리적보안
코드보안
접근제어 보안-----
전송보안
1. 데이터보안
- 개인정보 비식별화 .   정보XXXX                데이터 3법.. 아직적용안됨
개인식별 가능한 어떠한 정보 수집않는다....  너무 다향.... 
- 개인정보 재식별화 : 주변다른데이터 특정개인 식별력올라감. 
이름-연령-성별-거주지-직업-전화번호 + 취미-차량모델  :: 유일할수 있다. >> 프라이버시 유권해석 ..법률팀검토
비식별화 + 대체키 활용.  : 분석결과... 공유. 
2. 접근제어 보안
빅데이터 저장소(하둡) 개인정보, 거래정보, 행동이력. 
서디파티 접근제어기술 사용:
- 아파치 녹스 :    클라이언트 - DMG 구간 아파치녹스 - 하둡 에코시스템 + LDAP+KDC
- 아파치 센트리 서버
: 아파치 센트리버 , 정책 메타 스토어 연결.  각각 임팔라, 하이브 서버, 하둡 네임노트가 센트리 에이전트로 아파츠센트리버와 연결되어 있임. 
- 아파치 레인저 서버
: 아파치 레인저 서버, 정책메타 스토어 연결, 각각 HBase, 녹스, HDFS,스톰, 하이브서버 레인저 플러그인으로 연결. 
- 케베로스 
클라이언트- 하둡에코시스템은 티켓을 확인하고 접근을허용함. 
Kerberos Key Distribution Center 에 인증서버, 티켓발행서버가 있어 
인증서버에 클라이언트가 인증요청을 하고, 티켓발행서버가 티켓 획득 
R&R _ 분석 R&R 
분석가-모델러  - 데이터엔지니어 - 개발자인프라 - 관리자 기획
빅데이터 센터 : 표준 CEO - 빅데이터센터- 빅데이터 분석 부서
IT부서- 빅데이터 플랫폼팀 
파일럿 프로젝트 : 선행연구.  -PoC : Proof of Concept :  컨셉 증명
-PoV : Proof of Value : 가치증명
-BMT : BenchMark Test :  대규모 인프라에대한 성능 테스트

voc  Voice Of Customer 고객불만

거버넌스 : governence : 공동의 목표달성.  주어진 자원 제약하에서 모든 이해 당사자들이 책임감을 가지고 투명의사결정수행 제반장치. 

빅데이터 기술의 변화

낮은비용 스토리지 솔루션 -> 이머징기술. 

**소프트웨어 플랫폼.... 순수 오픈소스. + 기업 배포판 

 

1. 파일럿 프로젝트 도메인이해

요구사항 도출, 분석

차량내 디바이스(카 인포테인먼트 플랫폼 --> 빅데이터)

-> 제공서비스(주행거리연동보험, 운전행동 기반보험, 트래픽내비게이션, 광고, 카세어링)

요구사항 1:  차량의 다양한 장치로부터 발생하는 로그 파일을 수집해서 기능별상태 점검

데이터 발생위치, 종류, 발생주기, 수집주기, 수집규모, 타입, 분석주기, 처리 유형, 구분자, 스키마, 

요구사항 2: 운행정보 로그를 실시간 수집 주행패턴 분석

<파일럿시스템>

스마트카 로그 시뮬레이터 

->

스마트카 이상징후 예측 + 스마트카 운전패턴 군집 + 스마트카 차량용품 추천 : 빅데이터 마트 

-------------------------------------------------------------------------------------

스마트카 상태정보 +마스터 정보+ 운행정보+구매이력 : 데이터 웨어하우스

-------------------------------------------------------------------------------------

수집-> 적재-> 처리/탐색-> 분석/응용

728x90

점프 투 파이썬 << 출처 바로가기

AI Tech Pre-course << 출처 바로가기

파이썬(Python) 1. 플랫폼 독립적 인터프리터 언어 (플랫폼=OS, 인터프리터 언어=통역기를 사용하는 언어)
2. 객체지향 동적 타이핑 언어
(객체지향: 실행순서가 단위모듈 중심-method, attribute 갖음)
(동적타이핑언어 : 실행하는 시점에 프로그램이 사용해야할 데이터 타입을 결정함)
3. 처음 C언어로 구현되어 있음. 

1991년 암스테르담의 귀도 반 로섬(Guido Van Rossum)발표
- monty python's flying circus : 몬티파이썬 (영국코메디클럽)비행서커스 에서 이름유래. 
- 파이썬 개선사항(PEP: Python Enhancement Proposals) 최종의사결정자: 자비로운종신독재자
- 2010년..MS오픈소스 정책 동의하여 이직. 
- python (피톤) 그리스 신화속 괴물뱀

why Python
쉽고 간단하며 다양하다. 
이해하기 쉬운 문법, 사람의 시간이 기계 시간보다 중요하다. 
다양한 라이브러리: 무엇을 생각하든 그것을 구현할 수 있다. 
인터프리터(interpreter) 소스코드를 실행시점에 해석하여 컴퓨터 처리할 수 있도록 함
-실행속도 느림, 간단히 작성, 메모리 적개 필요. 
ex)
자바스크립트, HTML, 액션스크립트, SQL, python, ruby, 스칼라 등..
Source code > 인터프리터 > CPU
컴파일러(compiler) 소스코드를 기계어로 먼저번역, 해당 플래폼에 최적화 되어 프로그램을 실행. 
= 사람이 알 수 있는 고급언어를 기계만 알수 있는 저급언어로 변환
- 실행속도 빠름, 한번에 많은 기억장소 필요
ex) C, 자바, C++, C#
Source code > 컴파일러 > 어쌤블러 > CPU
* 파이썬은 컴파일언어 C로 작성, Assembler와 같은 기계어 변환 과정 거침
개발환경설정 1. 운영체재
2. 파이썬 인터프리터 : 2.7 ... 현업에서 사용, 현재 3.X  , 3.8 설치
Python: 일반적 파이썬, 기본적인 모듈 포함, 
Anaconda : 다양한 과학 계산용 모듈을 묶어서 패키지
3. 코드편집기(Editor)
메모장
VI editor :리눅스 기본문서 편집도구
Sublime Text Atom VS Code : 프로그래밍 특화된 문서 편집도구
PyCharm : 다양한 기능 갖춘 파이썬 전용 개발 도구
1) 설치되 어플리케이션 : VS Code(비쥬얼 스튜디오 코드) 
2) 웹 기반 인터랙티브 편집기 : 주피터, colab 

Type 1- Python Anaconda + VS Code
Type 2 - Data analysis _ Deep learning
: jupyter + colab(구글, 클라우드기반 인터랙티브 코드편집기)
설치
-anaconda
-vs code
아나콘다>미니콘다 설치
https://docs.conda.io/en/latest/miniconda.html

Cmder 사용시 필요.  - conda activate base
python  정상설치 확인
나가기 ctrl + z 엔터


VS Code
https://code.visualstudio.com/

설치
-Jupyter notebook
Jupyter
- IPython 커널 기반 대화형 파이썬 셸
- 일반적인 터미널 셀+웹기반 데이터 분석 NoteBook 제공
- 미디어, 텍스트, 코드, 수식 등을 하나의 문서로 표현가능
- 사실상 데이터 분석 Interative(엔터 바로 결과) Shell의 표준
- Julia + Python + R
설치 :C:\Users\miseo\python_workspace>conda install jupyter
실행 : C:\Users\miseo\python_workspace>jupyter notebook  
크롬. 선택
new 드롭박스 > python3 , 제목변경

- cell 단위로 실행 -> 실행시점 해당 코드가 memory에 올라감
실행 : ctrl 엔터 , shift 엔터, alt 엔터
툴팁 : shift  + tab
들여쓰기 : ctrl+]   or ctrl [
셀 나누기 : ctrl +shift  +-
아래 셀이랑 합치기 : esc    > shift M
셀 오려두기 x, 복사 :c(opy), 붙여넣게 :  v or shift +v
셀 지우기 : d, d   셀지우기 취소 : z
markdown 변환 m,m    
code 변환 : y,y
설치
-Colab
구글이 개발 클라우드 기반의 jupyter notebook
구글 드라이브 + GCP +jupyter 등이 합쳐져서 사용자가 손쉽게 접근
초반 여러가지 모듈 설치의 장점을 가짐
구글 드라이브 파일을 업로드하여 사용 가능한 장점 가짐 >> 노트북 사향 낮을때 유리
VSCode 등과 연결해서 사용가능
V100이상의 GPU를 무료로 쓸수 있다는 장점을 가짐. 
**딥러닝할때 많이씀. 

google colab 검색. 
https://colab.research.google.com/notebooks/intro.ipynb?utm_source=scs-index
단축키.. ctrl d..  > ctrl m d 



GCP : Google Cloud Platform 구글 클라우드 플랫폼. 
Variables & List 변수 : 가장 기초적인 프로그래밍 문법 개념
         데이터 값읕 저장하기 위한 메모리 공간의 프로그래밍상 이름. 


   
   

GPU : Graphic Processing Unit 그래픽 처리 장치 

2장 자료형  

 

숫자형 -7//4               .

>> 7/4 는 1.75, 7//4는 1,  -7 / 4 는 -1.75 , -7 // 4 는 -2

문자형  """ """  '''' '''

이스케이프 코드(\n) 삽입에 편리

** 이스케이프 코드 

: 프로그래밍 시 사용할 수 있도록 미리 정의해둔 문자조합. 출력물을 보기 좋게 정렬하는 용도로 이용. 

\n 줄바꿈  \t 수평탭

a = "="

b = "\n"

c="Python"  

print(a*20 +b +c+b+a*20)

==================== Python ====================

a = "abcdefg"

문자열 인덱싱 : a[-3]

e : 문자열 인덱싱은 문자열 내 특정한 값을 뽑아내는 역할 - 는 뒤에서부터

 

문자열 슬라이싱 :a[0:-3], a[:], a[:1]

abcd : 마이너스 사용은 가능.... 그런데... 뭔가. 이상...

abcdefg : 전체

a : 첫번째 자리에서 짜름

문자열 포멧팅 1 : "I eat %d %s apples." % (5,"five") , "%10s" % "hi"

%d : 정수, %f : 부동소수, %8 :8진수, %x : 16진수 %%: 문자%, %s : 문자열 %c : 문자 1개,

'I eat 5 five apples.'

%s 는 자동으로 문자열로 바꿔조서 고민안하고 써도됨

오른쪽 (정렬 +공백)은 양수 왼쪽(정렬+공백)은 음수

 

문자열 포멧팅 2 :"I eat apples, cans and ".format("five", 6, aaa="others")

'I eat five apples, 6 cans and others'

 

문자열 포멧팅 2-2 : "".format("hi"), "".format("hi") ,

"".format("hi") , "".format("hi") , "{{ and }}".format()

오른쪽정렬, 왼쪽정렬, 가운데 정렬 , 공백 채우기 , 중괄호처럼 포매팅 문자 사용시 두번사용

 

문자 개수 세기 : "test".count("t")

가운데 정렬 :^ 왼쪽 정렬 :< 오른쪽정렬 :>

가운데 정렬 +공백문자"!" :!^ 왼쪽 정렬 :!< 오른쪽정렬 :!>

 

리스트 알파벳 숫자 정렬 : a.sort()

리스트 뒤집기 : r.reverse()

a.rstrip() a.strip() a.replace("hi", "hellow")

A = [1,2,3,4]

A.insert(3,9)

A.remove(3) a.split()

A.pop()

a = [1,2,3] a.extend([4,5])

a = [1,2,3] a.extend([4,5]) print(a) a += [6,7]

print(a)

 

튜플(tuple)

t1 =()

t2= (1, 2,3,) # 항상 값이 변하지 않음

del t2[0] # 오류

 

딕셔너리 ... Map 과 유사

dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}

dic.keys()

dic.values()

dic.items()

dic.get("name")

dic.get("name222") #Nome

dic.clear()

"name" in a

 

 

파이썬(Python)은 1990년 암스테르담의 귀도 반 로섬(Guido Van Rossum)이 개발한 인터프리터1 언어이다

>>> a = 3 >>> if a > 1: ... print("a is greater than 1") ... a is greater than 1

 

>>> for a in [1, 2, 3]: ... print(a) ...

>>> i = 0 >>> while i < 3: ... i=i+1 ... print(i) ...

사용자 입력

a = input()

number = input("숫자를 입력하세요: ")

print("life" "is" "too short") 

 

print("life", "is", "too short")

 

f = open("새파일.txt", 'w') # w : 쓰기 , r : 읽기, a :마지막에 새로운내용 추가

 

f.readline() # \n 포함 리스트f.read() # 파일전체를 문자열로 리턴f.write("추가합니다. ")f.close()
import sys
args = sys.argv[1:]for i in args:

 

    print(i)

 

 

 

 

 

 

+ Recent posts