All Merged
All Merged
Systems
M. Tamer Özsu
Patrick Valduriez
Logically integrated
but
Physically distributed
q History
q
q
n Delivery modes
q Pull-only
q Push-only
q Hybrid
n Frequency
q Periodic
q Conditional
q Ad-hoc or irregular
n Communication Methods
q Unicast
q One-to-many
n Note: not all combinations make sense
© 2020, M.T. Özsu & P. Valduriez 18
Outline
n Introduction
q
Improved performance
Tokyo
SELECT ENAME,SAL
FROM EMP,ASG,PAY Boston Paris
Distributed Database
DBMS User
Application
Software
DBMS
Software
DBMS Communication
Software Subsystem
User
DBMS User Application
Software Query
DBMS
Software
User
Query
n Data independence
n Network transparency (or distribution transparency)
q Location transparency
q Fragmentation transparency
n Fragmentation transparency
n Replication transparency
q Failure atomicity
q Commit protocols
n Data replication
q Great for read-intensive workloads, problematic for updates
q Replication protocols
n Parallelism in execution
q Inter-query parallelism
q Intra-query parallelism
q
q Design issues
q
n Reliability
q How to make the system resilient to failures
q Atomicity and durability
n Replication
q Mutual consistency
q Freshness of copies
q Eager vs lazy
q Centralized vs distributed
n Parallel DBMS
q Objectives: high scalability and performance
q Not geo-distributed
q Cluster computing
q
q
n Distribution
q Whether the components of the system are located on the same machine or
not
n Heterogeneity
q Various levels (hardware, communications, operating system)
q DBMS important one
n data model, query language,transaction management algorithms
n Autonomy
q Not well understood and most troublesome
q Various versions
n Design autonomy: Ability of a component DBMS to decide on issues related to its
own design.
n Communication autonomy: Ability of a component DBMS to decide whether and
how to communicate with other DBMSs.
n Execution autonomy: Ability of a component DBMS to execute local operations in
any manner it wants to.
n PaaS – Platform-as-a-Service
n SaaS – Software-as-a-Service
n DaaS – Database-as-a-Service
n Completeness
q Decomposition of relation R into fragments R1, R2, ..., Rn is
complete if and only if each data item in R can also be found in
some Ri
n Reconstruction
q If relation R is decomposed into fragments R1, R2, ..., Rn, then
there should exist some relational operator ∇ such that
R = ∇1≤i≤nRi
n Disjointness
q If relation R is decomposed into fragments R1, R2, ..., Rn, and
data item di is in Rj, then di should not be in any other fragment
Rk (k ≠ j ).
n Non-replicated
q partitioned : each fragment resides at only one site
n Replicated
q fully replicated : each fragment at each site
q partially replicated : each fragment at some of the sites
n Rule of thumb:
n Database Information
q relationship
Example
m1: PNAME="Maintenance" Ù BUDGET≤200000
n Application Information
q minterm selectivities: sel(mi)
n The number of tuples of the relation that would be accessed by a
user query which is specified according to a given minterm
predicate mi.
Definition :
Rj = sFj(R), 1 ≤ j ≤ w
where Fj is a selection formula, which is (preferably) a minterm
predicate.
Therefore,
A horizontal fragment Ri of relation R consists of all the tuples of R
which satisfy a minterm predicate mi.
ê
Given a set of minterm predicates M, there are as many horizontal
fragments of relation R as there are minterm predicates.
Set of horizontal fragments also referred to as minterm fragments.
Preliminaries :
q Pr should be complete
q Pr should be minimal
n Example :
q Assume PROJ[PNO,PNAME,BUDGET,LOC] has two
applications defined on it.
q Find the budgets of projects at each location. (1)
q Find projects with budgets less than $200000. (2)
According to (1),
Pr={LOC=“Montreal”,LOC=“New York”,LOC=“Paris”}
which is complete.
Example :
Pr ={LOC=“Montreal”,LOC=“New York”, LOC=“Paris”,
BUDGET≤200000,BUDGET>200000}
Initialization :
q find a pi Î Pr such that pi partitions R according to Rule 1
q set Pr' = pi ; Pr ¬Pr – {pi} ; F ¬ {fi}
Iteratively add predicates to Pr' until it is complete
q find a pj Î Pr such that pj partitions some fk defined according to
minterm predicate over Pr' according to Rule 1
q set Pr' = Pr' È {pi}; Pr ¬Pr – {pi}; F ¬ F È {fi}
q if $pk Î Pr' which is nonrelevant then
Pr' ¬ Pr – {pi}
F ¬ F – {fi}
q Simple predicates
q For application (1)
p1 : LOC = “Montreal”
p2 : LOC = “New York”
p3 : LOC = “Paris”
q For application (2)
p4 : BUDGET ≤ 200000
p5 : BUDGET > 200000
q Pr = Pr' = {p1,p2,p3,p4,p5}
n Completeness
q Since Pr' is complete and minimal, the selection predicates are
complete
n Reconstruction
q If relation R is fragmented into FR = {R1,R2,…,Rr}
R = È"Ri ÎFR Ri
n Disjointness
q Minterm predicates that form the basis of fragmentation should
be mutually exclusive.
n Completeness
q Referential integrity
q Let R be the member relation of a link whose owner is relation S
which is fragmented as FS = {S1, S2, ..., Sn}. Furthermore, let A
be the join attribute between R and S. Then, for each tuple t of
R, there should be a tuple t' of S such that
t[A] = t' [A]
n Reconstruction
q Same as primary horizontal fragmentation.
n Disjointness
q Simple join graphs between the owner and the member
fragments.
n Overlapping fragments
q grouping
n Non-overlapping fragments
q splitting
n Application Information
q Attribute affinities
n a measure that indicates how closely related the attributes are
n This is obtained from more primitive usage data
q Attribute usage values
n Given a set of queries Q = {q1, q2,…, qq} that will run on the relation
R[A1, A2,…, An],
å
access
query access = access frequency of a query *
execution
all sites
Assume each query in the previous example accesses the attributes once
during each execution.
S1 S2 S3
Also assume the access frequencies q1 15 20 10
q2 5 0 0
q3 25 25 25
q4 3 0 0
Then
aff(A1, A3) = 15*1 + 20*1+10*1
= 45
and the attribute affinity matrix AA is
(Let A1=PNO, A2=PNAME, A3=BUDGET,
A4=LOC)
where
n
bond(Ax,Ay) = å
z =1
aff(A ,A )aff(A ,A )
z x z y
Ordering (0-3-1) :
cont(A0,BUDGET,PNO) = 2bond(A0, BUDGET)+2bond(BUDGET, PNO)
–2bond(A0 , PNO)
= 8820
Ordering (1-3-2) :
cont(PNO,BUDGET,PNAME) = 10150
Ordering (2-3-4) :
cont (PNAME,BUDGET,LOC) = 1780
Define
TQ = set of applications that access only TA
BQ = set of applications that access only BA
OQ = set of applications that access both TA and BA
and
CTQ = total number of accesses to attributes by applications
that access only TA
CBQ = total number of accesses to attributes by applications
that access only BA
COQ = total number of accesses to attributes by applications
that access both TA and BA
Then find the point along the diagonal that maximizes
CTQ*CBQ-COQ2
Two problems :
Cluster forming in the middle of the CA matrix
q Shift a row up and a column left and apply the algorithm to find
the “best” partitioning point
q Do this for all possible shifts
q Cost O(m2)
More than two clusters
q m-way partitioning
q try 1, 2, …, m–1 split points along diagonal and try to find the
best point for each of these
q Cost O(2m)
n Reconstruction
q Reconstruction can be achieved by
R = ⋈K Ri, "Ri Î FR
n Disjointness
q TID's are not considered to be overlapping since they are
maintained by the system
q Duplicated keys are not considered to be overlapping
q Data distribution
q
n Problem Statement
Given
F = {F1, F2, …, Fn} fragments
S ={S1, S2, …, Sm} network sites
Q = {q1, q2,…, qq} applications
Find the "optimal" distribution of F to S.
n Optimality
q Minimal cost
n Communication + storage + processing (read & update)
n Cost in terms of time (usually)
q Performance
Response time and/or throughput
q Constraints
n Per site constraints (storage & processing)
General Form
min(Total Cost)
subject to
response time constraint
storage constraint
processing constraint
Decision Variable
1 if fragment Fi is stored at site Sj
xij =
0 otherwise
n Total Cost
Processing component
access cost + integrity enforcement cost + concurrency control cost
q Access cost
n Constraints
q Response Time
execution time of query ≤ max. allowable response time for that query
n Solution Methods
q FAP is NP-complete
q DAP also NP-complete
n Heuristics based on
q single commodity warehouse location (for FAP)
q knapsack problem
q branch and bound techniques
q network flow
q Combined approaches
n Examplar: Schism
q Graph G=(V,E) where
n vertex vi ∈ V represents a tuple in database,
n edge e=(vi,vj) ∈ E represents a query that accesses both tuples vi
and vj;
n each edge has weight counting the no. of queries that access both
tuples
q Perform vertex disjoint graph partitioning
n Each vertex is assigned to a separate partition
⇩
SELECT PNAME FROM PROJ WHERE BUDGET>? AND LOC=‘?’
n If monitoring tuple-level access (E-Store), this will tell
you
n Involves:
q View management
q Security control
q Integrity control
n Objective :
q Ensure that authorized users perform correct operations on the
database, contributing to the maintenance of the database
integrity.
Example :
SELECT ENAME,PNO,RESP
FROM EMP, ASG
WHERE EMP.ENO = ASG.ENO
AND TITLE = "Syst. Anal."
n To restrict access
CREATE VIEW ESAME
AS SELECT *
FROM EMP E1, EMP E2
WHERE E1.TITLE = E2.TITLE
AND E1.ENO = USER
n Query
SELECT *
FROM ESAME
n Updatable
CREATE VIEW SYSAN(ENO,ENAME)
AS SELECT ENO,ENAME
FROM EMP
WHERE TITLE="Syst. Anal."
n Non-updatable
CREATE VIEW EG(ENAME,RESP)
AS SELECT ENAME,RESP
FROM EMP, ASG
WHERE EMP.ENO=ASG.ENO
n Immediate mode
q As part of the updating transaction, e.g. through 2PC
q View always consistent with base data and fast queries
q But increased transaction time to update base data
n Deferred mode (preferred in practice)
q Through separate refresh transactions
n No penalty on the updating transactions
q Triggered at different times with different trade-offs
n Lazily: just before evaluating a query on the view
n Periodically: every hour, every day, etc.
n Forcedly: after a number of predefined updates
n Basic idea
q Maintain a count of the number of derivations for each tuple in
the view
q Increment (resp. decrement) tuple counts based on insertions
(resp. deletions)
q A tuple in the view whose count is zero can be deleted
n Algorithm
1. Compute V+ and V- using V, base relations and diff. relations
2. Compute positive in V+ and negative counts in V-
3. Compute V+ È (V – V- ), deleting each tuple in V with count=0
n Optimal: computes exactly the view tuples that are
inserted or deleted
© 2020, M.T. Özsu & P. Valduriez 19
Exploiting Data Skew
n Basic idea
q Partition the relations on heavy / light values for join attributes
n Threshold depends on data size and user parameter
q Maintain the join of different parts using different plans
n Most cases done using delta processing (Counting)
n Few cases require pre-materialization of auxiliary views
q Rebalance the partitions to reflect heavy ↔ light changes
n Reasons for change:
q Much more/less occurrences of a value than before
q The heavy/light threshold changes due to change in data size
n Update times are amortized to account for occasional rebalancing
newR := R + R
P
a,b,c newR(a, b) · S(b, c) · T (c, a)
Maintenance Complexity
n Maintenance time:
q Updates
Time for updates to R:
to R: O(1)
O(1) totime
looktouplook upSTin VST
in V
q Updates to S and T: O(N) time to maintain VST
Time for updates to S and T : O(N) to maintain VST
n Extra O(N2) space needed for the view VST
pace: O(N ) to store input relations and VST (improvable to O(N 1.5 ))
2
worst-case optimality
O(N 0.5 ) " = 0.5
"
0 0.5 1
n• No algorithm
Known can approaches
maintenance -./(0
attain 𝑂(𝑁are ) for any
recovered γ >. 0.
by IVM "
∆R∗ (a, b) = {(a′ , b ′ ) '→ m}, compute the difference for each
n Skew-aware views (any partition of R)
nt strategies: Skew-aware View Evaluation f
! ′ ′
a,b,c R(a, b) · S L (b, c) · T L (c, a) ∆R(a ,b ) ·
Maintenance under update ∆𝑅 𝑎 1, 𝑏1
n Evaluation from left to right Time
′ ′
!
c) · TL (c, a) ∆R(a , b ) · SL (b ′ , c) · TL (c, a′ ) O(N ε )
c
q There are at most 𝑁 ' c values paired with b’
q For each such value c, we check (c,a’) in TL in O(1)
q Data security
q
n Data protection
q Prevents the physical content of data to be understood by
unauthorized users
q Uses encryption/decryption techniques (Public key)
n Access control
q Only authorized users perform operations they are allowed to on
database objects
q Discretionary access control (DAC)
n Long been provided by DBMS with authorization rules
q Multilevel access control (MAC)
n Increases security with security levels
n Main actors
q Subjects (users, groups of users) who execute operations
q Operations (in queries or application programs)
q Objects, on which operations are performed
n Checking whether a subject may perform an op. on an
object
q Authorization= (subject, op. type, object def.)
q Defined using GRANT OR REVOKE
q Centralized: one single user class (admin.) may grant or revoke
q Decentralized, with op. type GRANT
n More flexible but recursive revoking process which needs the hierarchy
of grants
n Behavioral constraints
q Regulate application behavior, e.g., dependencies in the
relational model
n Two components
q Integrity constraint specification
q Integrity constraint enforcement
n Procedural
q Control embedded in each application program
n Declarative
q Assertions in predicate calculus
q Easy to define constraints
q Definition of database consistency clear
q But inefficient to check assertions for each update
n Limit the search space
n Decrease the number of data accesses/assertion
n Preventive strategies
n Checking at compile time
Precompiled constraints
Express preconditions that must be satisfied by all tuples in a
relation for a given update type
(INSERT, DELETE, MODIFY)
NEW - ranges over new tuples to be inserted
OLD - ranges over old tuples to be deleted
General Form
CHECK ON <relation> [WHEN <update type>]
<qualification>
Precompiled constraints
q Domain constraint
q Transition constraint
General constraints
Constraints that must always be true. Formulae of tuple
relational calculus where all variables are quantified.
General Form
CHECK ON <variable>:<relation>,(<qualification>)
q Functional dependency
CHECK ON e1:EMP, e2:EMP
(e1.ENAME = e2.ENAME IF e1.ENO = e2.ENO)
q Constraint with aggregate function
CHECK ON g:ASG, j:PROJ
(SUM(g.DUR WHERE g.PNO = j.PNO) < 100 IF
j.PNAME = "CAD/CAM")
Two methods
n Detection
Execute update u: D ® Du
If Du is inconsistent then
if possible: compensate Du ® Du’
else
undo Du ® D
n Preventive
Execute u: D ® Du only if Du will be consistent
q Determine valid programs
UPDATE PROJ
SET BUDGET = BUDGET*1.1
WHERE PNAME = "CAD/CAM"
AND NEW.BUDGET ≥ 500000
AND NEW.BUDGET ≤ 1000000
Type of u
insert R- empty
delete R+ empty
modify R+ È (R – R-)
n Problems:
q Definition of constraints
n Consideration for fragments
q Where to store
n Replication
n Non-replicated : fragments
q Enforcement
n Minimize costs
n Individual assertions
q Single relation, single variable
q Domain constraint
q Multi-relation, multi-variable
n foreign key
Begin_transaction
…
Read
Read
…
Write
Read
…
Commit
n Read set (RS)
q The set of data items that are read by a transaction
n Write set (WS)
q The set of data items whose values are changed by this transaction
n Base set (BS)
q RS ∪ WS
ATOMICITY
q all or nothing
CONSISTENCY
q no violation of integrity constraints
ISOLATION
q concurrent changes invisible Þ serializable
DURABILITY
q committed updates persist
n Pessimistic
q Two-Phase Locking-based (2PL)
n Centralized (primary site) 2PL
n Primary copy 2PL
n Distributed 2PL
q Timestamp Ordering (TO)
n Basic TO
n Multiversion TO
n Conservative TO
n Optimistic
q Locking-based
q Timestamp ordering-based
Ti Tj
Local WFG
Global WFG
Basic T/O:
for Ri(x) for Wi(x)
if ts(Ti) < wts(x) if ts(Ti) < rts(x) and ts(Ti) < wts(x)
then reject Ri(x) then reject Wi(x)
else accept Ri(x) else accept Wi(x)
rts(x) ¬ ts(Ti) wts(x) ¬ ts(Ti)
© 2020, M.T. Özsu & P. Valduriez 24
Basic Timestamp Ordering
if ts(Ti) < wts(x) if ts(Ti) < rts(x) and ts(Ti) < wts(x)
then reject Ri(x) then reject Wi(x)
else accept Ri(x) else accept Wi(x)
rts(x) ¬ ts(Ti) wts(x) ¬ ts(Ti)
Pessimistic execution
Optimistic execution
Check if first 2
Conditions hold
Positive Yes
Any ?
neg? Update event clock:
No max(own,coord TM)
If global commit:
1) Persist 𝑇! updates
2) Update event clock
© 2020, M.T. Özsu & P. Valduriez 37
Outline
n Distributed Transaction Processing
q
q Distributed Reliability
Problem:
How to maintain
atomicity
durability
properties of transactions
n Transaction failures
q Transaction aborts (unilaterally or due to deadlock)
n System (site) failures
q Failure of processor, main memory, power supply, …
q Main memory contents are lost, but secondary storage contents
are safe
q Partial vs. total failure
n Media failures
q Failure of secondary storage devices → stored data is lost
q Head crash/controller failure
n Communication failures
q Lost/undeliverable messages
q Network partitioning
© 2020, M.T. Özsu & P. Valduriez 40
Distributed Reliability Protocols
n Commit protocols
q How to execute commit command for distributed transactions.
q Issue: how to ensure atomicity and durability?
n Termination protocols
q If a failure occurs, how can the remaining operational sites deal with it.
q Non-blocking: the occurrence of failures should not force the sites to
wait until the failure is repaired to terminate the transaction.
n Recovery protocols
q When a failure occurs, how do the sites where the failure occurred deal
with it.
q Independent: a failed site can determine the outcome of a transaction
without having to obtain remote information.
n Independent recovery Þ non-blocking termination
Coordinator Participant
INITIAL INITIAL
Commit Prepare
Prepare Vote-commit
Prepare
Vote-abort
WAIT READY
Vote-abort Vote-commit Global-abort Global-commit
Global-abort Global-commit Ack Ack
COMMIT
P P
P P
C C C
P P
P P
Phase 1 Phase 2
INITIAL INITIAL
A RE
PREP
write
begin commit write No Ready to
abort Commit?
B ORT
E-A
(Unilateral abort)
VOT
Yes
WAIT VOTE-COMMIT write
ready
write COMMIT
end of transaction ABORT
Phase 1
C P P P P
Phase 2
P
P
P Global
decision
P
C made
independently
P
P
P
P
Vote-commit/
Prepare Vote-abort
To improve performance by
1) Reduce the number of messages between coordinator &
participants
2) Reduce the number of time logs are written
n Presumed Abort 2PC
q Participant polls coordinator about transaction’s outcome
q No information → abort the transaction
n Presumed Commit 2PC
q Participant polls coordinator about transaction’s outcome
q No information → assume transaction is committed
q Not an exact dual of presumed abort 2PC
Coordinator
n Timeout in INITIAL
q Who cares INITIAL
Participant
n Timeout in INITIAL
q Coordinator must have failed INITIAL
in INITIAL state
Prepare
q Unilaterally abort Prepare
Vote-commit
ABORT COMMIT
Coordinator
n Failure in INITIAL
q Start the commit process upon INITIAL
recovery
Commit
n Failure in WAIT Prepare
been received
q Otherwise the termination protocol is
involved
Participant
n Failure in INITIAL
q Unilaterally abort upon recovery
n Failure in READY INITIAL
n Blocking
q Ready implies that the participant waits for the coordinator
q If coordinator fails, site is blocked until recovery
q Blocking reduces availability
n Independent recovery is not possible
n However, it is known that:
q Independent recovery protocols exist only for single site failures;
no independent recovery protocol exists which is resilient to
multiple-site failures.
n So we search for these protocols – 3PC
n 3PC is non-blocking.
n A commit protocols is non-blocking iff
q it is synchronous within one state transition, and
q its state transition diagram contains
n no state which is “adjacent” to both a commit and an abort state,
and
n no non-committable state which is “adjacent” to a commit state
n Adjacent: possible to go from one stat to another with a
single state transition
n Committable: all sites have voted to commit a
transaction
q e.g.: COMMIT state
Coordinator Participant
INITIAL INITIAL
Commit Prepare
Prepare Vote-commit
Prepare
Vote-abort
WAIT READY
Vote-abort Vote-commit Global-abort Prepare-to-commit
Global-abort Prepare-to-commit Ack Ready-to-commit
PRE- PRE-
ABORT ABORT
COMMIT COMMIT
Ready-to-commit Global-commit
Global-commit Ack
COMMIT COMMIT
3PC Protocol Actions Coordinator Participant
INITIAL INITIAL
A RE
PREP
write
begin commit No Ready to
write abort
RT Commit?
A BO
TE-
(Unilateral abort)
VO
Yes
WAIT VOTE-COMMIT
write ready
Yes GLOBAL-ABORT
Any No? write abort READY
OMMIT
E-TO-C
No PREPAR
write
prepare to commit
Abort Type of
msg
ABORT ACK
Prepare-
PRE- write abort to-commit
COMMIT READY-TO-COMMIT write
prepare to commit
ABORT
write commit GLOBAL-COM
MIT
PRE-
COMMIT
COMMIT ACK
write commit
write
end of transaction
COMMIT
© 2020, M.T. Özsu & P. Valduriez 58
Network Partitioning
n Simple partitioning
q Only two partitions
n Multiple partitioning
q More than two partitions
n Formal bounds:
q There exists no non-blocking protocol that is resilient to a
network partition if messages are lost when partition occurs.
q There exist non-blocking protocols which are resilient to a single
network partition if all undeliverable messages are returned to
sender.
q There exists no non-blocking protocol which is resilient to a
multiple partition.
No
Ignore and
Wait
if all are Ack (not with bal’,val’)
then val ← proposer wants &
nbal ← bal
No
else val ← val’ & nbal ← bal nbal = ack.bal? Ignore
Yes
Record
accepted(nbal,val)
2
Propriedades ACID
1. Atomicidade: Tudo ou nada
2. Consistência: Mantém a integridade dos dados
3. Isolamento: Transações parecem ser executadas de forma isolada
4. Durabilidade: Após o commit, as mudanças são permanentes
3
Desafios em Sistemas Distribuídos
Dados distribuídos por vários nós
Necessidade de coordenação entre nós
Possibilidade de falhas parciais
Latência de rede
4
Controlo de Concorrência
1. Bloqueio (Locking)
2. Ordenação por Marcas Temporais (Timestamp Ordering)
3. Métodos Otimistas
5
Bloqueio em Duas Fases (2PL)
1. Fase de crescimento: é possível adquirir bloqueios, mas nenhum pode ser libertado
2. Fase de contração: é possível libertar bloqueios, mas nenhum pode ser adquirido
6
Tipos de Bloqueios
Bloqueio Partilhado: para leituras
Bloqueio Exclusivo: para escritas
7
2PL Estrito
Mantém bloqueios de escrita até ao fim da transação
Vantagens:
Evita reversões em cascata
Garante recuperabilidade
Desvantagem: Reduz concorrência
8
2PL Distribuído
Abordagens:
1. Centralizada: Um nó gere todos os bloqueios
2. Distribuída: Cada nó gere bloqueios para seus dados locais
9
2PL Centralizado
Processo:
1. Transação solicita bloqueio ao nó central
2. Nó central verifica compatibilidade
3. Concede ou rejeita a aquisição do bloqueio
Prós e Contras:
Mais simples de implementar
Ponto único de falha
Possível bottleneck
10
2PL Totalmente Distribuído
Processo:
1. Transação solicita bloqueio ao nó que possui os dados necessários
2. Nó verifica compatibilidade localmente
3. Concede ou rejeita a aquisição do bloqueio
Prós e Contras:
Mais robusto e escalável
Mais complexo de implementar
Pode levar a impasses distribuídos
11
Impasses (Deadlocks)
Definição:
Situação onde duas ou mais transações esperam uma pela outra indefinidamente
Exemplo:
T1 tem bloqueio em A, precisa de B
T2 tem bloqueio em B, precisa de A
12
Gestão de Impasses
Métodos:
1. Prevenção
2. Detecção e Resolução
Abordagens de Detecção:
Centralizada
Hierárquica
Distribuída
13
Detecção de Impasses Centralizada
Processo:
1. Nó central adquire informações das intenções de lock de todos os nós
2. Constrói grafo global
3. Procura periodicamente ciclos no grafo global
Prós e Contras:
Mais simples de implementar
Possível ponto único de falha em sistemas complexos
14
Detecção de Impasses Distribuída
Processo:
1. Cada nó mantém grafo das intenções de lock locais
2. Nós trocam informações sobre potenciais ciclos
3. Algoritmo de detecção é executado em múltiplos nós
Prós e Contras:
Mais escalável
Mais complexo de implementar e manter
15
Resolução de Impasses
Métodos:
1. Selecionar uma "vítima" (transação a abortar)
2. Rollback da transação "vítima"
3. Libertar os seus locks
Possíveis critérios de seleção:
Idade da transação
Progresso da transação
Número de recursos bloqueados
16
Commit Atómico Distribuído
Desafio:
Garantir que uma transação distribuída seja totalmente commit ou totalmente abort em
todos os nós participantes
Soluções:
1. Protocolo de Commit em Duas Fases (2PC)
2. Protocolo de Commit em Três Fases (3PC)
17
Protocolo de Commit em Duas Fases (2PC)
Fases:
1. Fase de Votação
2. Fase de Decisão
Participantes:
Coordenador (decide resultado da transacção)
Participantes (nós envolvidos na transacção)
18
2PC: Fase de Votação
1. Coordenador envia "preparar" aos participantes
2. Participantes verificam se podem fazer commit
3. Participantes respondem "sim" ou "não" ao coordenador
4. Participantes entram em estado "preparado" se votarem "sim"
19
2PC: Fase de Decisão
1. Se todos votaram "sim", coordenador decide commit
2. Se algum votou "não", coordenador decide abortar
3. Coordenador envia decisão aos participantes
4. Participantes executam a decisão e confirmam
20
2PC: Logging
Coordenador:
BEGIN_COMMIT
GLOBAL_COMMIT ou GLOBAL_ABORT
COMPLETE
Participante:
READY
COMMIT ou ABORT
21
Limitações do 2PC
1. Bloqueante se o coordenador falhar após "preparar"
2. Participantes podem ficar em estado de incerteza
3. Desempenho afetado por latência de rede
4. Vulnerável a falhas de rede (partições)
22
Protocolo de Commit em Três Fases (3PC)
Objetivo:
Tornar o protocolo de commit não-bloqueante
Fases:
1. Fase de Votação
2. Fase de Pré-commit
3. Fase de Commit Final
23
3PC: Fase de Votação
Idêntica à fase de votação do 2PC
Participantes votam "sim" ou "não"
24
3PC: Fase de Pré-commit
1. Se todos votaram "sim", coordenador envia "pré-commit"
2. Participantes confirmam recepção do "pré-commit"
3. Estado intermediário entre preparado e commit
25
3PC: Fase de Commit Final
1. Coordenador envia "commit" final
2. Participantes executam commit e confirmam
Vantagem:
Participantes podem decidir em caso de falha do coordenador
26
Comparação 2PC vs 3PC
2PC:
Mais simples e amplamente utilizado
Bloqueante em algumas situações de falha
3PC:
Não-bloqueante
Maior overhead de mensagens
Mais complexo de implementar
27
Recuperação em Transações Distribuídas
Cenários:
1. Falha de participante
2. Falha de coordenador
3. Falhas de rede (partições)
Princípio:
Usar informações de log para reconstruir o estado
28
Recuperação de Falha de Participante
1. Participante consulta o seu log ao reiniciar
2. Se encontrar READY, contacta coordenador para decisão final
3. Se encontrar COMMIT ou ABORT, executa a ação correspondente
29
Recuperação de Falha de Coordenador
1. Novo coordenador é eleito (se necessário)
2. Novo coordenador consulta participantes sobre estado da transação
3. Decide com base nas respostas dos participantes
30
Conclusão
Transações distribuídas são complexas, mas essenciais
2PL e 2PC/3PC são fundamentais para garantir ACID
Balancear consistência, disponibilidade e tolerância a partições (Teorema CAP)
Sistemas modernos podem "relaxar" algumas destas garantias para melhorar o seu
desempenho
31
HBase
Base de dados não-relacional NoSQL
orientado a colunas
Baseado no modelo do Google BigTable
Oferece alta escalabilidade e desempenho
32
Componentes do HBase
HMaster: gerencia os RegionServers
RegionServer: gerencia as regiões de dados
ZooKeeper: coordenação e gestão de estado
33
Replicação no HBase
Replicação assíncrona entre clusters
Suporte a topologias master-slave e multi-master
Melhora a disponibilidade e tolerância a falhas
34
Fragmentação no HBase
Dados divididos em regiões
Distribuição automática de regiões entre RegionServers
Balanceamento de carga automático
35
Transações no HBase
Suporte a transações ACID apenas ao nível da linha
Isolamento baseado em versões
Implementado através do componente Transaction Manager
36
Phoenix
Camada SQL sobre o HBase
Permite consultas SQL e transações ACID
Mapeia tabelas SQL para tabelas HBase
37
Componentes do Phoenix
Cliente Phoenix: driver JDBC
Phoenix Query Server: execução de consultas
Phoenix Compiler: otimização de consultas
38
Replicação com Phoenix
Suporta replicação nativa do HBase
Permite consultas SQL em réplicas secundárias
Melhora o desempenho de leitura
39
Transações no Phoenix
Transações ACID completas
Isolamento snapshot
40
Hive
Data warehouse distribuído para análise de big data
Suporta consultas SQL-like (HiveQL)
Executa jobs MapReduce ou Spark
41
Componentes do Hive
Metastore: armazena metadados das tabelas
Driver: compilação e otimização de consultas
Execution Engine: execução de consultas (MapReduce/Spark)
42
Fragmentação no Hive
Suporta particionamento de tabelas
Permite bucketing para melhor distribuição de dados
Otimiza consultas com pruning de partições
43
Transações no Hive
Suporte a transações ACID (desde a versão 0.14)
Implementado sobre o HDFS e MapReduce/Tez
Usa controlo de concorrência otimista
44
Hue
Interface web para ecossistema Hadoop
Facilita interação com HBase, Hive e outros componentes
Oferece editores SQL, navegadores de dados e dashboards
45
Componentes do Hue
Editor SQL: interface para consultas Hive e HBase
File Browser: navegação no HDFS
Job Browser: monitoramento de jobs
46
O que é o ZooKeeper?
Serviço de coordenação para sistemas distribuídos
Desenvolvido pela Apache Software Foundation
Actua como um "árbitro confiável" entre serviços
distribuídos
47
O que o ZooKeeper Coordena?
Principalmente:
1. Metadados e estados de configuração
2. Informações de controlo e coordenação entre serviços
Não é usado para:
Coordenar dados de aplicação em grande escala
Armazenar ficheiros grandes
48
Problemas Resolvidos pelo ZooKeeper
1. Manter consistência entre múltiplos servidores
2. Lidar com falhas parciais no sistema
3. Gerir estados partilhados correctamente
49
Como é que o ZooKeeper Funciona?
Usa uma estrutura hierárquica chamada "znodes", similar a um sistema de ficheiros
Cada znode pode armazenar até 1MB de dados
Clientes observam znodes para detectar mudanças
50
Mecanismo de Watchers
Clientes podem "observar" znodes para perceber mudanças
São enviadas notificações quando ocorrem alterações
Permite reacção rápida a mudanças de configuração ou estado
51
Casos de utilização "normais"
1. Configuração dinâmica: Atualizar configurações em tempo real
2. Eleição de líder: Determinar o servidor líder num cluster
3. Locks distribuídos: Coordenar acesso a recursos compartilhados
4. Filas de tarefas: Distribuir trabalho entre múltiplos trabalhadores
52
Mapeamento de Conceitos
Replicação: implementada no HBase e Phoenix
Fragmentação: presente no HBase (regiões) e Hive (partições)
Transações: suportadas em HBase, Phoenix e Hive
Controlo de concorrência: MVCC (Multi-Version Concurrency Control) no
HBase/Phoenix, otimista no Hive
53
Principles of Distributed Database
Systems
M. Tamer Özsu
Patrick Valduriez
n Why replicate?
q System availability
n Avoid single points of failure
q Performance
n Localization
q Scalability
n Scalability in numbers and geographic area
q Application requirements
n Why not replicate?
q Replication transparency
q Consistency issues
n Updates are costly
n Availability may suffer if not careful
x1 x2 … xn
q
q
n Mutual Consistency
q How do we keep the values of physical copies of a logical data
item synchronized?
q Strong consistency
n All copies are updated within the context of the update transaction
n When the update transaction completes, all copies have the same
value
n Typically achieved through 2PC
q Weak consistency
n Eventual consistency: the copies are not identical when update
transaction completes, but they eventually converge to the same
value
n Many versions possible:
q Time-bounds
q Value-bounds
q Drifts
Site A Site B
x x
Eager
Lazy
n Changes are propagated within the scope of the transaction making the
changes. The ACID properties apply to all copy updates.
q Synchronous
q Deferred
n ROWA protocol: Read-one/Write-all
Transaction
updates commit
● Lazy replication first executes the updating transaction on one copy. After
the transaction commits, the changes are propagated to all other copies
(refresh transactions)
● While the propagation takes place, the copies are mutually inconsistent.
● The time the copies are mutually inconsistent is an adjustable parameter
which is application dependent.
Transaction
updates commit
Site 1 Site 2 Site 3 Site 4
● There is only one copy which can be updated (the master), all others
(slave copies) are updated reflecting the changes to the master.
● Changes can be initiated at any of the copies. That is, any of the
sites which owns a copy can update the value of the data item.
Transaction
updates commit
Transaction
updates commit
q Replication Protocols
q
Centralized Distributed
2
Eager Primary Copy/Full Transparency
Transaction
Op(x) . . . Op(y ) . . . C ommit
3
2
1
1 2
Transaction
Op(x) . . . Op(y ) . . . C ommit
3
2
1
1 2
2
1
2 1 3
n Critical issue:
q Concurrent Writes initiated at different master sites are executed in the
same order at each slave site
q Local histories are serializable (this is easy)
n Advantages
q Simple and easy to implement
n Disadvantage
q Very high communication overhead
n n replicas; m update operations in each transaction: n*m messages (assume
no multicasting)
n For throughput of k tps: k* n*m messages
n Alternative
q Use group communication + deferred update to slaves to reduce
messages
3
1 2 4
Example 3 R1 (x)
R1 (x)
W2 (x)
result
W2 (x)
OK
W2 (y )
W2 (y )
Site M (Master) holds x, y; SiteB OK
OK
C1
C1
HM = {W2 (xM ), W2 (yM ), C2 , W1 (yM ), C1 }
C1
HB = {R1 (xB ), C1 , W2R (xB ), W2R (yB ), C2R , W1R (xB ), C1R } OK
Refresh(T2 )
R y )}
), W 2 (
{ W 2 (x
OK R
OK
Refresh(T1 )
)}
{ W 1 (x
R
OK
Time
3
1 2 1 2
Centralized Distributed
q
q Replication and Failure Management
n Physical integration
q Source databases integrated and the integrated database is
materialized
q Data warehouses
n Logical integration
q Global conceptual schema is virtual and not materialized
q Enterprise Information Integration (EII)
Materialized
Global
Database
ETL
tools
n Local-as-view
q The GCS definition is assumed to exist, and each LCS is treated
as a view definition over it
n Global-as-view
q The GCS is defined as a set of views over the LCSs
Objects Objects
expressible as queries expressible as queries
over the source DBMSs over the GCS
GCS
Schema Generator
Schema
Mapping
Schema
Integration
Schema
Matching
q
q
N 1
City WORKER WORKS IN PROJECT Location
N
Title Salary
Duration
CONTRACTED BY
PAY(TITLE, SAL)
Client name Address
n Schema heterogeneity
q Structural heterogeneity
n Type conflicts
n Dependency conflicts
n Key conflicts
n Behavioral conflicts
q Semantic heterogeneity
n More important and harder to deal with
n Synonyms, homonyms, hypernyms
n Different ontology
n Imprecise wording
n Other complications
q Insufficient schema and instance information
q Unavailability of schema documentation
q Subjectivity of matching
n Issues that affect schema matching
q Schema versus instance matching
q Element versus structure level matching
q Matching cardinality
Individual matchers
Schema-based Instance-based
lbip l spo
lili l pon
llit l ons
lity l nsi
n 3-grams of string “Resp” are
q Res
q esp
n 3-gram similarity: 2/12 = 0.17
© 2020, M.T. Özsu & P. Valduriez 20
Edit Distance Example
Probabilistic
knowledge
Dk , Dl Classifier
Classification
predictions
q Schema Integration
q
q
Integration process
Binary n-ary
One-pass Iterative
q Schema Mapping
q
Given
q A source LCS: 𝒮 = {𝑆" }
q A target GCS: 𝒯 = {𝑇" }
q A set of value correspondences discovered during schema
matching phase: 𝒱 = {𝑉" }
Produce a set of queries that, when executed, will create
GCS data instances from the source data.
We are looking, for each 𝑇# , a query 𝑄# that is defined on a
(possibly proper) subset of the relations in 𝑆 such that,
when executed, will generate data for 𝑇𝑖 from the source
relations
© 2020, M.T. Özsu & P. Valduriez 33
Mapping Creation Algorithm
General idea:
q
q Query Rewriting
q
n Mediator/wrapper architecture
n MDB query processing architecture
n Query rewriting using views
n Query optimization and execution
n Query translation and execution
Mediator Mediator
n Communication autonomy
q The ability to terminate services at any time
q How to answer queries completely?
n Design autonomy
q The ability to restrict the availability and accuracy of information
needed for query optimization
q How to obtain cost information?
n Execution autonomy
q The ability to execute queries in unpredictable ways
q How to adapt to this?
Query on
global relations
Global Global/local
REWRITING Schema correspondences
MEDIATOR Query on
SITE local relations
Distributed
query execution plan
Results
EMP(E#,ENAME,TITLE,CITY)
WORKS(E#,P#,RESP,DUR)
Q(E#,TITLE,P#) :- EMP(E#,ENAME,"Programmer",CITY),
WORKS(E#,P#,RESP,DUR).
Q(E#,TITLE,P#) :- EMP(E#,ENAME,TITLE,CITY),
WORKS(E#,P#,RESP,24).
Step2: produces
Q′(e,p) :- EMP1(e,ENAME,TITLE,"Paris"),
WORKS1(e,p,DUR). (q1)
Q′(e,p) :- EMP2(e,ENAME,TITLE,"Paris"),
WORKS1(e,p,DUR). (q2)
q
q
q Optimization Issues
Query-
specific rules
SELECT ENAME,PNAME,DUR
FROM EMPASG
WHERE CITY = "Paris" AND DUR>24
m
Union
w1 w2
Join Scan(DUR> 24)
65
SQL Wrapper for Text Files
https://blog.verbat.com/hadoop-ecosystem-beginners-overview/
BDDA - MCD - Paulo Vieira 5
Hadoop – casos de utilização
• Data warehouse, extract load transform (ELT) e extract transform load
(ETL)
• Eventos e processamento complexo de eventos
• Ingestão e processamento de dados de sensors, mensagens ou logs
• Associado geralmente ao conceito de IoT (Internet of Things)
• Mineração de dados e machine learning
• Java API
SELECT
state as "State",
count(city) as "City Count",
sum(population) as "Population Sum"
FROM
us_population
GROUP BY
state
ORDER BY Phoenix in 15 minutes or less | Apache Phoenix
sum(population) DESC
;
BDDA - MCD - Paulo Vieira 28
DEMO – Phoenix & HUE
https://parquet.apache.org/
https://parquet.apache.org/
3
Hadoop: Características Principais
Armazenamento distribuído | Processamento paralelo
Tolerância a falhas
Alta disponibilidade
É uma plataforma de armazenamento e processamento de dados baseado num
conceito central: data locality
O objectivo é aproximar a capacidade de computação/processamento dos dados
É um sistema schema-on-read
4
Componentes Principais do Hadoop
1. HDFS (Hadoop Distributed File System)
2. MapReduce
3. YARN (Yet Another Resource Negotiator)
5
HDFS: Visão Geral
Sistema de ficheiros distribuído
Projetado para armazenar grandes volumes
de dados
Executa em commodity hardware
Constituído por blocos que são distribuídos
(replicados) através de um ou mais nós de
um cluster
Os ficheiros são divididos de acordo
com uma determinada dimensão de
bloco na altura do upload
6
HDFS: Visão Geral (cont.)
Imutável: dados commited no sistema de ficheiros não podem ser actualizados
WORM (write once, read many)
Os blocos tem um tamanho, por omissão, de 128Mb
Os ficheiros são separados na altura da ingestão
Se um cluster tiver mais de um nó, os blocos são distribuídos
São também replicados num factor de replicação (tipicamente 3, embora no
modo pseudo-distribuído seja 1)
Aumenta a probabilidade de data locality
7
HDFS: Interacção
Shell (hdfs dfs)
hdfs dfs -put lord-of-the-rings.txt /data/books
hdfs dfs –ls
Java API
RESTful proxy interfaces (HttpFS e WebHDFS)
8
HDFS: Arquitetura
Arquitetura master-slave
NameNode (master)
DataNodes (slaves)
9
NameNode
Processo obrigatório e necessário para o funcionamento do HDFS
Responsável pela durabilidade e consistência dos metadados:
Armazena metadados de todos os ficheiros e diretórios
Gere o namespace do sistema de ficheiros
Regula o acesso aos ficheiros pelos clientes
Executa operações como abrir, fechar e renomear ficheiros
Mantém a árvore do sistema de ficheiros
Ponto único de falha (pode ser resolvido com NameNode secundário)
10
DataNode
Responsável por gerir o armazenamento do bloco e acessos de leitura e escrita, assim
como replicação dos blocos
Reportam ao NameNode com listas de blocos que estão a armazenar
Executam operações de leitura e escrita para os clientes do sistema de ficheiros
Realizam criação, eliminação e replicação de blocos sob instrução do NameNode
11
12
YARN: Introdução
Yet Another Resource Negotiator
Introduzido no Hadoop 2.0
Orquestrador do processamento de dados
no Hadoop
Separa as funcionalidades de "gestão
de recursos" do "motor de
processamento"
13
YARN: Componentes Principais
1. ResourceManager
2. NodeManager
3. ApplicationMaster
4. Container
14
YARN: ResourceManager
Gestor global de recursos
Aloca recursos para aplicações distribuídas
Responsável por garantir os recursos computacionais às aplicações em execução no
clusters
Disponibilizados na forma de containers que são combinações pré-definidas de cores
CPU e memória
Monitoriza a capacidade no cluster quando as aplicações terminam e libertam
recursos
15
YARN: NodeManager
Agente em cada nó de computação
Responsável pelos containers
Monitoriza o uso de recursos
16
YARN: ApplicationMaster
Negoceia recursos com o ResourceManager
Trabalha com os NodeManagers para executar e monitorizar tarefas
17
YARN: Container
Unidade de recursos no YARN
Inclui elementos como memória, CPU, disco, rede, etc.
18
YARN: Fluxo de Trabalho
1. Cliente submete aplicação
2. ResourceManager cria container para ApplicationMaster
3. ApplicationMaster negoceia recursos adicionais
4. ApplicationMaster inicia a execução nos containers alocados
19
20
YARN: Vantagens
Maior escalabilidade
Melhor utilização de recursos do cluster
Suporta workloads não-MapReduce
21
MapReduce: Visão Geral
Modelo de programação para
processamento de dados em larga escala
Divide o processamento em duas fases:
Map e Reduce
22
MapReduce: Fase Map
Processa os dados de entrada
Produz pares chave-valor intermédios
23
MapReduce: Fase Reduce
Combina os pares chave-valor intermédios
Produz o resultado final
24
O que é o ZooKeeper?
Serviço de coordenação para sistemas distribuídos
Desenvolvido pela Apache Software Foundation
Actua como um "árbitro confiável" entre serviços
distribuídos
25
O que o ZooKeeper Coordena?
Principalmente:
1. Metadados e estados de configuração
2. Informações de controlo e coordenação entre serviços
Não é usado para:
Coordenar dados de aplicação em grande escala
Armazenar ficheiros grandes
26
Problemas Resolvidos pelo ZooKeeper
1. Manter consistência entre múltiplos servidores
2. Lidar com falhas parciais no sistema
3. Gerir estados partilhados correctamente
27
Como é que o ZooKeeper Funciona?
Usa uma estrutura hierárquica chamada "znodes", similar a um sistema de ficheiros
Cada znode pode armazenar até 1MB de dados
Clientes observam znodes para detectar mudanças
28
Mecanismo de Watchers
Clientes podem "observar" znodes para perceber mudanças
São enviadas notificações quando ocorrem alterações
Permite reacção rápida a mudanças de configuração ou estado
29
Casos de utilização "normais"
1. Configuração dinâmica: Atualizar configurações em tempo real
2. Eleição de líder: Determinar o servidor líder num cluster
3. Locks distribuídos: Coordenar acesso a recursos compartilhados
4. Filas de tarefas: Distribuir trabalho entre múltiplos trabalhadores
30
Exemplo prático: contagem de palavras num texto
"O Iscte – Instituto Universitário de Lisboa é uma instituição pública de
ensino universitário, criada em 1972, que dispõe de campi em Lisboa e
Sintra. Em 2010 foi implementada uma nova estrutura organizacional que
resultou na composição de unidades orgânicas descentralizadas: quatro
Escolas, 16 Departamentos, oito Unidades de Investigação."
31
32
33
Conclusão
Hadoop: framework para processamento distribuído
HDFS: armazenamento distribuído
MapReduce: modelo de programação para processamento em larga escala
YARN: gestão de recursos e agendamento de tarefas
ZooKeeper: coordenação de sistemas distribuídos
34
Referências
1. Apache Hadoop. (n.d.). Apache Hadoop. https://hadoop.apache.org/
2. White, T. (2015). Hadoop: The Definitive Guide. O'Reilly Media.
3. Apache YARN. (n.d.). Apache Hadoop YARN.
https://hadoop.apache.org/docs/current/hadoop-yarn/hadoop-yarn-site/YARN.html
4. Apache ZooKeeper. (n.d.). Apache ZooKeeper. https://zookeeper.apache.org/
5. Sammer, E. (2012). Hadoop Operations. O'Reilly Media.
35
hadoop-yarn-zookeeper-presentation.md 2024-10-20
Hadoop: Introdução
Framework de código aberto para processamento distribuído
Projetado para escalar de servidores individuais a milhares de máquinas
Google e Yahoo! foram os primeiros a enfrentar os desafios de escalabilidade na internet
Em 2006 é publicado como projecto open source na Apache Software Foundation
Tolerância a falhas
Alta disponibilidade
É uma plataforma de armazenamento e processamento de dados baseado num conceito central:
data locality
O objectivo é aproximar a capacidade de computação/processamento dos dados
É um sistema schema-on-read
HDFS: Interacção
Shell (hdfs dfs)
2/8
hadoop-yarn-zookeeper-presentation.md 2024-10-20
Java API
RESTful proxy interfaces (HttpFS e WebHDFS)
HDFS: Arquitetura
Arquitetura master-slave
NameNode (master)
DataNodes (slaves)
NameNode
Processo obrigatório e necessário para o funcionamento do HDFS
Responsável pela durabilidade e consistência dos metadados:
Armazena metadados de todos os ficheiros e diretórios
Gere o namespace do sistema de ficheiros
Regula o acesso aos ficheiros pelos clientes
Executa operações como abrir, fechar e renomear ficheiros
Mantém a árvore do sistema de ficheiros
Ponto único de falha (pode ser resolvido com NameNode secundário)
DataNode
Responsável por gerir o armazenamento do bloco e acessos de leitura e escrita, assim como
replicação dos blocos
Reportam ao NameNode com listas de blocos que estão a armazenar
Executam operações de leitura e escrita para os clientes do sistema de ficheiros
Realizam criação, eliminação e replicação de blocos sob instrução do NameNode
3/8
hadoop-yarn-zookeeper-presentation.md 2024-10-20
YARN: Introdução
Yet Another Resource Negotiator
Introduzido no Hadoop 2.0
Orquestrador do processamento de dados no Hadoop
Separa as funcionalidades de "gestão de recursos" do "motor de processamento"
YARN: ResourceManager
Gestor global de recursos
Aloca recursos para aplicações distribuídas
Responsável por garantir os recursos computacionais às aplicações em execução no clusters
Disponibilizados na forma de containers que são combinações pré-definidas de cores CPU e
memória
Monitoriza a capacidade no cluster quando as aplicações terminam e libertam recursos
YARN: NodeManager
Agente em cada nó de computação
Responsável pelos containers
Monitoriza o uso de recursos
YARN: ApplicationMaster
Negoceia recursos com o ResourceManager
Trabalha com os NodeManagers para executar e monitorizar tarefas
YARN: Container
Unidade de recursos no YARN
Inclui elementos como memória, CPU, disco, rede, etc.
5/8
hadoop-yarn-zookeeper-presentation.md 2024-10-20
YARN: Vantagens
Maior escalabilidade
Melhor utilização de recursos do cluster
Suporta workloads não-MapReduce
Conclusão
Hadoop: framework para processamento distribuído
7/8
hadoop-yarn-zookeeper-presentation.md 2024-10-20
Referências
. Apache Hadoop. (n.d.). Apache Hadoop. https://hadoop.apache.org/
. White, T. (2015). Hadoop: The Definitive Guide. O'Reilly Media.
. Apache YARN. (n.d.). Apache Hadoop YARN. https://hadoop.apache.org/docs/current/hadoop-
yarn/hadoop-yarn-site/YARN.html
. Apache ZooKeeper. (n.d.). Apache ZooKeeper. https://zookeeper.apache.org/
. Sammer, E. (2012). Hadoop Operations. O'Reilly Media.
8/8
Docker
Criação de
containers e
principais comandos
Paulo Vieira 2024
O que é o Docker?
Lançado em 2013, rapidamente se tornou um padrão na indústria
Plataforma de código aberto para criação de containers
Permite empacotar as aplicações e as suas dependências
Baseada em Linux
2
Para que serve o Docker?
1. Criar ambientes isolados e consistentes
2. Facilitar o desenvolvimento e deploy de aplicações
3. Garantir que as aplicações funcionem de forma idêntica em diferentes ambientes
4. Simplificar a gestão de infraestrutura e escalabilidade
3
Componentes principais do Docker
1. Docker Engine: O runtime que executa os containers
2. Docker Images: Templates de leitura para criar containers
3. Docker containers: Instâncias em execução de imagens Docker
4. Dockerfile: Script para construir imagens Docker
5. Docker Hub: Repositório público de imagens Docker
4
Comandos Docker Essenciais
# Listar contentores
docker ps
# Executar um contentor
docker run [opções] imagem
# Parar um contentor
docker stop id_contentor
# Remover um contentor
docker rm id_contentor
# Listar imagens
docker images
6
Exemplo de docker-compose.yml
version: '3'
services:
web:
build: .
ports:
- "5000:5000"
redis:
image: "redis:alpine"
7
Comandos Docker Compose
# Iniciar serviços
docker-compose up
# Parar serviços
docker-compose down
8
Variáveis de Ambiente no Docker
Usadas para configurar contentores em tempo de execução
Podem ser definidas no Dockerfile, docker-compose.yml ou na linha de comando
9
No Dockerfile:
ENV VARIAVEL_EXEMPLO=valor
No docker-compose.yml:
services:
web:
environment:
- VARIAVEL_EXEMPLO=valor
Na linha de comando:
docker run -e VARIAVEL_EXEMPLO=valor imagem
10
Vantagens do Docker
1. Consistência: "Funciona na minha máquina"
torna-se "Funciona em qualquer lugar"
2. Isolamento: Aplicações e dependências são
encapsuladas
3. Eficiência: Usa menos recursos que as
máquinas virtuais tradicionais
4. Portabilidade: Fácil de evoluir entre
ambientes (dev, test, prod)
5. Escalabilidade: Facilita a criação e gestão de
múltiplas instâncias
11
Casos de utilização
Desenvolvimento de software: Ambientes de desenvolvimento consistentes
Microserviços: Facilita a arquitetura e deployment de microserviços
Continuous Integration/Continuous Deployment (CI/CD): Automatiza testes e
deployment
Aplicações legadas: Facilita a migração e modernização
Infraestrutura como código: Define ambientes de forma programática
12
Exemplo prático: Tutorial
13
hbase-tutorial-completo.md 2024-10-20
Tutorial 2: HBase
O Apache HBase é uma solução de armazenamento e processamento de dados NoSQL, inspirada no
modelo do Google BigTable. Desenvolvido sobre o Hadoop Distributed File System (HDFS), o HBase
oferece uma abordagem distribuída, não relacional e orientada a colunas para gerir eficientemente grandes
volumes de informação. Esta base de dados permite acesso aleatório e consistente a conjuntos de dados
extremamente vastos, proporcionando uma plataforma escalável para aplicações que exigem alta
performance no tratamento de informação estruturadas.
Componentes Principais do HBase:
1. HMaster
O HMaster é o processo principal que gere o cluster HBase. Monitoriza e coordena os RegionServers, além
de gerir as operações de criação, desativação ou divisão de regiões. É fundamental para garantir a correta
distribuição e escalabilidade dos dados no cluster.
2. RegionServer
Os RegionServers são responsáveis pelo armazenamento e gestão dos dados em HBase. Cada servidor
gere uma ou mais regiões, que são fragmentos da tabela. Além disso, processam as operações de leitura e
escrita, tornando-se cruciais para o desempenho global do sistema.
3. Zookeeper
O Zookeeper é utilizado pelo HBase para a coordenação dos serviços distribuídos. Ele assegura que os
processos como o HMaster e os RegionServers mantenham o estado de sincronização e comunicação.
Funciona como um "supervisor" para garantir que o sistema distribua a carga de trabalho de forma eficaz.
4. Região
Uma região é a unidade básica de escalabilidade em HBase. Cada tabela é dividida em várias regiões e, à
medida que os dados aumentam, novas regiões são criadas e distribuídas pelos RegionServers. Isto
permite uma divisão eficiente dos dados e um aumento de capacidade sem comprometer o desempenho.
5. Tabela
Uma tabela em HBase é uma coleção de linhas organizadas por famílias de colunas. Cada linha é
identificada por uma chave de linha única, e as famílias de colunas agrupam colunas relacionadas,
facilitando a gestão e armazenamento dos dados.
1/8
hbase-tutorial-completo.md 2024-10-20
6. Família de Colunas
Uma família de colunas é um grupo de colunas relacionadas dentro de uma tabela. Cada família de colunas
é armazenada separadamente, permitindo uma maior eficiência na leitura e escrita de dados,
especialmente quando apenas algumas colunas são consultadas.
Objectivos e Exploração da Web UI
Antes de avançarmos com os desafios, vamos explorar a interface Web UI do HBase, disponível em
http://localhost:16010. A Web UI oferece uma visão geral do estado do cluster, permitindo monitorizar o
desempenho, as regiões ativas e a "saúde" do sistema.
Desafio Inicial: Explore a Web UI e responda às seguintes questões:
Quantos RegionServers estão ativos no sistema?
Qual é a região com mais leituras/escritas nas últimas 24 horas?
Qual é a tabela com mais dados armazenados atualmente?
Configuração do HBase (com Docker)
Para começar a usar o HBase, vamos configurá-lo usando o Docker.
. Instale o Docker, se ainda não o tiver feito.
. Execute o seguinte comando para iniciar um contentor HBase:
docker ps
2/8
hbase-tutorial-completo.md 2024-10-20
Inserir Dados
Insira alguns dados na tabela:
Remover Dados
Para remover uma célula específica, é necessário identificar a linha/coluna:
Consultas e Filtros
O HBase oferece várias formas de consultar e filtrar dados:
Consulta Simples
Para obter uma linha específica, especifico a tabela e a família de colunas:
Scan
Para ver todas as linhas da tabela:
scan 'turma'
. Combinação de Filtros:
Desafios
Tenta resolver os desafios seguintes. Em caso de dúvida, consulta a documentação.
Escolas
. Cria uma nova tabela chamada "escola" com as famílias de colunas "detalhes" e "estatisticas".
. Insire dados para três escolas diferentes, incluindo nome, localização e número de alunos.
. Faz uma consulta para obter todos os dados de uma escola específica.
. Atualiza o número de alunos de uma das escolas.
. Cria uma nova família de colunas chamada "professores" na tabela "escola".
. Adiciona informações sobre dois professores para cada escola.
. Remove uma escola inteira da tabela.
. Faz um scan na tabela para ver todos os dados restantes.
. Conta o número de linhas na tabela "escola".
4/8
hbase-tutorial-completo.md 2024-10-20
. Insire dados para três escolas diferentes, incluindo nome, localização e número de alunos.
5/8
hbase-tutorial-completo.md 2024-10-20
. Faz uma consulta para obter todos os dados de uma escola específica.
scan 'escola'
count 'escola'
6/8
hbase-tutorial-completo.md 2024-10-20
disable 'escola'
enable 'escola'
Produtos
. Cria uma tabela para armazenar informação de produtos com duas column families – características
específicas e gerais. Como características específicas, considera o nome e a descrição, e como
características gerais o preço, a quantidade e a taxa de IVA.
. Insire dados para representar cinco produtos diferentes, incluindo as características específicas atrás
definidas.
. Obtem todos os detalhes de um produto específico por nome ou por taxa de IVA.
scan 'produtos'
7/8
hbase-tutorial-completo.md 2024-10-20
Alunos
. Cria uma tabela para armazenar informações de alunos com detalhes sobre cursos e notas. As notas
pertencem a unidades curriculares e são atribuídas entre A (excelente) e E (Insuficiente).
disable 'alunos'
. Elimina permanentemente a tabela de alunos após garantir que não há dados importantes.
drop 'alunos'
8/8
Tutorial Hive
Instalação do Hive e Kick-off
9. Submit
10. Esta versão utiliza Hive-on-MR (Hive on MapReduce) que foi descontinuado. As alternativas
são Spark, que será introduzido na próxima UC.