Creative portal «Terra Ad Caelum»
Book Reader
Books overview

 

Contents

756
Hadoop: The Definitive Guide

Author(s): Tom White

 

Hadoop: The Definitive Guide

 
2

Dedication

 
4

Foreword

 
5

Preface

 
7
    

Administrative Notes

 
9
    

What’s New in the Fourth Edition?

 
10
    

What’s New in the Third Edition?

 
11
    

What’s New in the Second Edition?

 
12
    

Conventions Used in This Book

 
13
    

Using Code Examples

 
14
    

Safari® Books Online

 
15
    

How to Contact Us

 
16
    

Acknowledgments

 
17

I. Hadoop Fundamentals

 
19
    

1. Meet Hadoop

 
21
        

Data!

 
23
        

Data Storage and Analysis

 
25
        

Querying All Your Data

 
26
        

Beyond Batch

 
27
        

Comparison with Other Systems

 
29
            
Relational Database Management Systems
 
29
            
Grid Computing
 
30
            
Volunteer Computing
 
31
        

A Brief History of Apache Hadoop

 
32
        

What’s in This Book?

 
35
    

2. MapReduce

 
39
        

A Weather Dataset

 
41
            
Data Format
 
41
        

Analyzing the Data with Unix Tools

 
43
        

Analyzing the Data with Hadoop

 
45
            
Map and Reduce
 
45
            
Java MapReduce
 
46
                
A test run
 
49
        

Scaling Out

 
52
            
Data Flow
 
52
            
Combiner Functions
 
55
                
Specifying a combiner function
 
57
            
Running a Distributed MapReduce Job
 
57
        

Hadoop Streaming

 
59
            
Ruby
 
59
            
Python
 
61
    

3. The Hadoop Distributed Filesystem

 
62
        

The Design of HDFS

 
64
        

HDFS Concepts

 
66
            
Blocks
 
66
            
Namenodes and Datanodes
 
67
            
Block Caching
 
68
            
HDFS Federation
 
68
            
HDFS High Availability
 
68
                
Failover and fencing
 
70
        

The Command-Line Interface

 
71
            
Basic Filesystem Operations
 
71
        

Hadoop Filesystems

 
73
            
Interfaces
 
74
                
HTTP
 
74
                
C
 
76
                
NFS
 
76
                
FUSE
 
76
        

The Java Interface

 
77
            
Reading Data from a Hadoop URL
 
77
            
Reading Data Using the FileSystem API
 
78
                
FSDataInputStream
 
79
            
Writing Data
 
80
                
FSDataOutputStream
 
81
            
Directories
 
82
            
Querying the Filesystem
 
82
                
File metadata: FileStatus
 
82
                
Listing files
 
83
                
File patterns
 
84
                
PathFilter
 
85
            
Deleting Data
 
86
        

Data Flow

 
87
            
Anatomy of a File Read
 
87
            
Anatomy of a File Write
 
89
            
Coherency Model
 
92
                
Consequences for application design
 
93
        

Parallel Copying with distcp

 
94
            
Keeping an HDFS Cluster Balanced
 
95
    

4. YARN

 
96
        

Anatomy of a YARN Application Run

 
98
            
Resource Requests
 
99
            
Application Lifespan
 
99
            
Building YARN Applications
 
100
        

YARN Compared to MapReduce 1

 
101
        

Scheduling in YARN

 
104
            
Scheduler Options
 
104
            
Capacity Scheduler Configuration
 
106
                
Queue placement
 
107
            
Fair Scheduler Configuration
 
107
                
Enabling the Fair Scheduler
 
108
                
Queue configuration
 
108
                
Queue placement
 
110
                
Preemption
 
110
            
Delay Scheduling
 
111
            
Dominant Resource Fairness
 
111
        

Further Reading

 
113
    

5. Hadoop I/O

 
114
        

Data Integrity

 
116
            
Data Integrity in HDFS
 
116
            
LocalFileSystem
 
117
            
ChecksumFileSystem
 
117
        

Compression

 
119
            
Codecs
 
120
                
Compressing and decompressing streams with CompressionCodec
 
120
                
Inferring CompressionCodecs using CompressionCodecFactory
 
121
                
Native libraries
 
122
                    CodecPool
 
123
            
Compression and Input Splits
 
123
            
Using Compression in MapReduce
 
124
                
Compressing map output
 
126
        

Serialization

 
127
            
The Writable Interface
 
128
                
WritableComparable and comparators
 
129
            
Writable Classes
 
129
                
Writable wrappers for Java primitives
 
129
                
Text
 
131
                    Indexing
 
131
                    Unicode
 
132
                    Iteration
 
133
                    Mutability
 
133
                    Resorting to String
 
134
                
BytesWritable
 
134
                
NullWritable
 
134
                
ObjectWritable and GenericWritable
 
135
                
Writable collections
 
135
            
Implementing a Custom Writable
 
136
                
Implementing a RawComparator for speed
 
138
                
Custom comparators
 
139
            
Serialization Frameworks
 
139
                
Serialization IDL
 
140
        

File-Based Data Structures

 
141
            
SequenceFile
 
141
                
Writing a SequenceFile
 
141
                
Reading a SequenceFile
 
142
                
Displaying a SequenceFile with the command-line interface
 
144
                
Sorting and merging SequenceFiles
 
145
                
The SequenceFile format
 
145
            
MapFile
 
147
                
MapFile variants
 
147
            
Other File Formats and Column-Oriented Formats
 
147

II. MapReduce

 
150
    

6. Developing a MapReduce Application

 
152
        

The Configuration API

 
154
            
Combining Resources
 
154
            
Variable Expansion
 
155
        

Setting Up the Development Environment

 
156
            
Managing Configuration
 
157
            
GenericOptionsParser, Tool, and ToolRunner
 
159
        

Writing a Unit Test with MRUnit

 
162
            
Mapper
 
162
            
Reducer
 
164
        

Running Locally on Test Data

 
166
            
Running a Job in a Local Job Runner
 
166
            
Testing the Driver
 
167
        

Running on a Cluster

 
169
            
Packaging a Job
 
169
                
The client classpath
 
169
                
The task classpath
 
169
                
Packaging dependencies
 
170
                
Task classpath precedence
 
170
            
Launching a Job
 
170
            
The MapReduce Web UI
 
172
                
The resource manager page
 
172
                
The MapReduce job page
 
173
            
Retrieving the Results
 
174
            
Debugging a Job
 
175
                
The tasks and task attempts pages
 
176
                
Handling malformed data
 
177
            
Hadoop Logs
 
178
            
Remote Debugging
 
179
        

Tuning a Job

 
181
            
Profiling Tasks
 
181
                
The HPROF profiler
 
182
        

MapReduce Workflows

 
183
            
Decomposing a Problem into MapReduce Jobs
 
183
            
JobControl
 
184
            
Apache Oozie
 
185
                
Defining an Oozie workflow
 
185
                
Packaging and deploying an Oozie workflow application
 
188
                
Running an Oozie workflow job
 
188
    

7. How MapReduce Works

 
190
        

Anatomy of a MapReduce Job Run

 
192
            
Job Submission
 
193
            
Job Initialization
 
193
            
Task Assignment
 
194
            
Task Execution
 
195
                
Streaming
 
195
            
Progress and Status Updates
 
196
            
Job Completion
 
198
        

Failures

 
199
            
Task Failure
 
199
            
Application Master Failure
 
200
            
Node Manager Failure
 
200
            
Resource Manager Failure
 
201
        

Shuffle and Sort

 
203
            
The Map Side
 
203
            
The Reduce Side
 
204
            
Configuration Tuning
 
207
        

Task Execution

 
210
            
The Task Execution Environment
 
210
                
Streaming environment variables
 
210
            
Speculative Execution
 
210
            
Output Committers
 
212
                
Task side-effect files
 
213
    

8. MapReduce Types and Formats

 
215
        

MapReduce Types

 
217
            
The Default MapReduce Job
 
219
                
The default Streaming job
 
223
                
Keys and values in Streaming
 
223
        

Input Formats

 
225
            
Input Splits and Records
 
225
                
FileInputFormat
 
226
                
FileInputFormat input paths
 
227
                
FileInputFormat input splits
 
228
                
Small files and CombineFileInputFormat
 
229
                
Preventing splitting
 
230
                
File information in the mapper
 
230
                
Processing a whole file as a record
 
231
            
Text Input
 
234
                
TextInputFormat
 
234
                    Controlling the maximum line length
 
235
                
KeyValueTextInputFormat
 
235
                
NLineInputFormat
 
235
                
XML
 
236
            
Binary Input
 
237
                
SequenceFileInputFormat
 
237
                
SequenceFileAsTextInputFormat
 
237
                
SequenceFileAsBinaryInputFormat
 
238
                
FixedLengthInputFormat
 
238
            
Multiple Inputs
 
238
            
Database Input (and Output)
 
239
        

Output Formats

 
240
            
Text Output
 
240
            
Binary Output
 
240
                
SequenceFileOutputFormat
 
240
                
SequenceFileAsBinaryOutputFormat
 
241
                
MapFileOutputFormat
 
241
            
Multiple Outputs
 
241
                
An example: Partitioning data
 
241
                
MultipleOutputs
 
242
            
Lazy Output
 
244
            
Database Output
 
244
    

9. MapReduce Features

 
246
        

Counters

 
248
            
Built-in Counters
 
248
                
Task counters
 
248
                
Job counters
 
250
            
User-Defined Java Counters
 
251
                
Dynamic counters
 
253
                
Retrieving counters
 
253
            
User-Defined Streaming Counters
 
254
        

Sorting

 
255
            
Preparation
 
255
            
Partial Sort
 
256
            
Total Sort
 
257
            
Secondary Sort
 
259
                
Java code
 
261
                
Streaming
 
263
        

Joins

 
265
            
Map-Side Joins
 
266
            
Reduce-Side Joins
 
266
        

Side Data Distribution

 
270
            
Using the Job Configuration
 
270
            
Distributed Cache
 
270
                
Usage
 
270
                
How it works
 
272
                
The distributed cache API
 
273
        

MapReduce Library Classes

 
275

III. Hadoop Operations

 
276
    

10. Setting Up a Hadoop Cluster

 
278
        

Cluster Specification

 
280
            
Cluster Sizing
 
281
                
Master node scenarios
 
281
            
Network Topology
 
281
                
Rack awareness
 
282
        

Cluster Setup and Installation

 
284
            
Installing Java
 
284
            
Creating Unix User Accounts
 
284
            
Installing Hadoop
 
284
            
Configuring SSH
 
284
            
Configuring Hadoop
 
285
            
Formatting the HDFS Filesystem
 
285
            
Starting and Stopping the Daemons
 
285
            
Creating User Directories
 
286
        

Hadoop Configuration

 
288
            
Configuration Management
 
288
            
Environment Settings
 
289
                
Java
 
289
                
Memory heap size
 
289
                
System logfiles
 
290
                
SSH settings
 
291
            
Important Hadoop Daemon Properties
 
291
                
HDFS
 
292
                
YARN
 
294
                
Memory settings in YARN and MapReduce
 
295
                
CPU settings in YARN and MapReduce
 
297
            
Hadoop Daemon Addresses and Ports
 
297
            
Other Hadoop Properties
 
300
                
Cluster membership
 
300
                
Buffer size
 
300
                
HDFS block size
 
301
                
Reserved storage space
 
301
                
Trash
 
301
                
Job scheduler
 
301
                
Reduce slow start
 
301
                
Short-circuit local reads
 
302
        

Security

 
303
            
Kerberos and Hadoop
 
303
                
An example
 
304
            
Delegation Tokens
 
305
            
Other Security Enhancements
 
306
        

Benchmarking a Hadoop Cluster

 
308
            
Hadoop Benchmarks
 
308
                
Benchmarking MapReduce with TeraSort
 
308
                
Other benchmarks
 
309
            
User Jobs
 
309
    

11. Administering Hadoop

 
311
        

HDFS

 
313
            
Persistent Data Structures
 
313
                
Namenode directory structure
 
313
                
The filesystem image and edit log
 
314
                
Secondary namenode directory structure
 
316
                
Datanode directory structure
 
317
            
Safe Mode
 
317
                
Entering and leaving safe mode
 
318
            
Audit Logging
 
319
            
Tools
 
319
                
dfsadmin
 
319
                
Filesystem check (fsck)
 
320
                    Finding the blocks for a file
 
321
                
Datanode block scanner
 
322
                
Balancer
 
323
        

Monitoring

 
324
            
Logging
 
324
                
Setting log levels
 
324
                
Getting stack traces
 
324
            
Metrics and JMX
 
324
        

Maintenance

 
326
            
Routine Administration Procedures
 
326
                
Metadata backups
 
326
                
Data backups
 
326
                
Filesystem check (fsck)
 
327
                
Filesystem balancer
 
327
            
Commissioning and Decommissioning Nodes
 
327
                
Commissioning new nodes
 
327
                
Decommissioning old nodes
 
328
            
Upgrades
 
329
                
HDFS data and metadata upgrades
 
330
                    Start the upgrade
 
332
                    Wait until the upgrade is complete
 
332
                    Check the upgrade
 
332
                    Roll back the upgrade (optional)
 
332
                    Finalize the upgrade (optional)
 
332

IV. Related Projects

 
334
    

12. Avro

 
336
        

Avro Data Types and Schemas

 
339
        

In-Memory Serialization and Deserialization

 
343
            
The Specific API
 
344
        

Avro Datafiles

 
346
        

Interoperability

 
348
            
Python API
 
348
            
Avro Tools
 
348
        

Schema Resolution

 
350
        

Sort Order

 
352
        

Avro MapReduce

 
354
        

Sorting Using Avro MapReduce

 
357
        

Avro in Other Languages

 
359
    

13. Parquet

 
360
        

Data Model

 
362
            
Nested Encoding
 
363
        

Parquet File Format

 
365
        

Parquet Configuration

 
367
        

Writing and Reading Parquet Files

 
368
            
Avro, Protocol Buffers, and Thrift
 
369
                
Projection and read schemas
 
370
        

Parquet MapReduce

 
372
    

14. Flume

 
374
        

Installing Flume

 
376
        

An Example

 
377
        

Transactions and Reliability

 
379
            
Batching
 
379
        

The HDFS Sink

 
380
            
Partitioning and Interceptors
 
381
            
File Formats
 
381
        

Fan Out

 
383
            
Delivery Guarantees
 
383
            
Replicating and Multiplexing Selectors
 
384
        

Distribution: Agent Tiers

 
385
            
Delivery Guarantees
 
387
        

Sink Groups

 
389
        

Integrating Flume with Applications

 
392
        

Component Catalog

 
393
        

Further Reading

 
395
    

15. Sqoop

 
396
        

Getting Sqoop

 
398
        

Sqoop Connectors

 
400
        

A Sample Import

 
401
            
Text and Binary File Formats
 
402
        

Generated Code

 
404
            
Additional Serialization Systems
 
404
        

Imports: A Deeper Look

 
405
            
Controlling the Import
 
407
            
Imports and Consistency
 
407
            
Incremental Imports
 
407
            
Direct-Mode Imports
 
408
        

Working with Imported Data

 
409
            
Imported Data and Hive
 
409
        

Importing Large Objects

 
412
        

Performing an Export

 
414
        

Exports: A Deeper Look

 
416
            
Exports and Transactionality
 
417
            
Exports and SequenceFiles
 
418
        

Further Reading

 
420
    

16. Pig

 
421
        

Installing and Running Pig

 
423
            
Execution Types
 
423
                
Local mode
 
423
                
MapReduce mode
 
423
            
Running Pig Programs
 
424
            
Grunt
 
424
            
Pig Latin Editors
 
425
        

An Example

 
426
            
Generating Examples
 
427
        

Comparison with Databases

 
429
        

Pig Latin

 
430
            
Structure
 
430
            
Statements
 
431
            
Expressions
 
435
            
Types
 
436
            
Schemas
 
438
                
Using Hive tables with HCatalog
 
439
                
Validation and nulls
 
439
                
Schema merging
 
441
            
Functions
 
441
                
Other libraries
 
443
            
Macros
 
444
        

User-Defined Functions

 
445
            
A Filter UDF
 
445
                
Leveraging types
 
447
            
An Eval UDF
 
447
                
Dynamic invokers
 
448
            
A Load UDF
 
448
                
Using a schema
 
450
        

Data Processing Operators

 
452
            
Loading and Storing Data
 
452
            
Filtering Data
 
452
                
FOREACH...GENERATE
 
452
                
STREAM
 
453
            
Grouping and Joining Data
 
454
                
JOIN
 
454
                
COGROUP
 
455
                
CROSS
 
456
                
GROUP
 
457
            
Sorting Data
 
458
            
Combining and Splitting Data
 
459
        

Pig in Practice

 
460
            
Parallelism
 
460
            
Anonymous Relations
 
460
            
Parameter Substitution
 
460
                
Dynamic parameters
 
461
                
Parameter substitution processing
 
461
        

Further Reading

 
462
    

17. Hive

 
463
        

Installing Hive

 
465
            
The Hive Shell
 
465
        

An Example

 
467
        

Running Hive

 
469
            
Configuring Hive
 
469
                
Execution engines
 
470
                
Logging
 
470
            
Hive Services
 
471
                
Hive clients
 
471
            
The Metastore
 
472
        

Comparison with Traditional Databases

 
476
            
Schema on Read Versus Schema on Write
 
476
            
Updates, Transactions, and Indexes
 
476
            
SQL-on-Hadoop Alternatives
 
477
        

HiveQL

 
479
            
Data Types
 
479
                
Primitive types
 
480
                
Complex types
 
481
            
Operators and Functions
 
482
                
Conversions
 
482
        

Tables

 
483
            
Managed Tables and External Tables
 
483
            
Partitions and Buckets
 
484
                
Partitions
 
484
                
Buckets
 
485
            
Storage Formats
 
487
                
The default storage format: Delimited text
 
488
                
Binary storage formats: Sequence files, Avro datafiles, Parquet files, RCFiles, and ORCFiles
 
489
                
Using a custom SerDe: RegexSerDe
 
489
                
Storage handlers
 
490
            
Importing Data
 
490
                
Inserts
 
490
                
Multitable insert
 
491
                
CREATE TABLE...AS SELECT
 
491
            
Altering Tables
 
492
            
Dropping Tables
 
492
        

Querying Data

 
494
            
Sorting and Aggregating
 
494
            
MapReduce Scripts
 
494
            
Joins
 
495
                
Inner joins
 
495
                
Outer joins
 
496
                
Semi joins
 
497
                
Map joins
 
497
            
Subqueries
 
497
            
Views
 
498
        

User-Defined Functions

 
500
            
Writing a UDF
 
501
            
Writing a UDAF
 
502
                
A more complex UDAF
 
505
        

Further Reading

 
507
    

18. Crunch

 
508
        

An Example

 
510
        

The Core Crunch API

 
513
            
Primitive Operations
 
513
                
union()
 
513
                
parallelDo()
 
513
                
groupByKey()
 
514
                
combineValues()
 
515
            
Types
 
516
                
Records and tuples
 
517
            
Sources and Targets
 
518
                
Reading from a source
 
519
                
Writing to a target
 
519
                
Existing outputs
 
520
                
Combined sources and targets
 
520
            
Functions
 
520
                
Serialization of functions
 
520
                
Object reuse
 
521
            
Materialization
 
522
                
PObject
 
523
        

Pipeline Execution

 
525
            
Running a Pipeline
 
525
                
Asynchronous execution
 
525
                
Debugging
 
526
            
Stopping a Pipeline
 
526
            
Inspecting a Crunch Plan
 
526
            
Iterative Algorithms
 
529
            
Checkpointing a Pipeline
 
530
        

Crunch Libraries

 
532
        

Further Reading

 
534
    

19. Spark

 
535
        

Installing Spark

 
537
        

An Example

 
538
            
Spark Applications, Jobs, Stages, and Tasks
 
539
            
A Scala Standalone Application
 
539
            
A Java Example
 
540
            
A Python Example
 
541
        

Resilient Distributed Datasets

 
543
            
Creation
 
543
            
Transformations and Actions
 
544
                
Aggregation transformations
 
545
            
Persistence
 
546
                
Persistence levels
 
547
            
Serialization
 
548
                
Data
 
548
                
Functions
 
549
        

Shared Variables

 
550
            
Broadcast Variables
 
550
            
Accumulators
 
550
        

Anatomy of a Spark Job Run

 
552
            
Job Submission
 
552
            
DAG Construction
 
553
            
Task Scheduling
 
556
            
Task Execution
 
556
        

Executors and Cluster Managers

 
557
            
Spark on YARN
 
557
                
YARN client mode
 
558
                
YARN cluster mode
 
559
        

Further Reading

 
562
    

20. HBase

 
563
        

HBasics

 
565
            
Backdrop
 
565
        

Concepts

 
566
            
Whirlwind Tour of the Data Model
 
566
                
Regions
 
567
                
Locking
 
567
            
Implementation
 
567
                
HBase in operation
 
569
        

Installation

 
571
            
Test Drive
 
571
        

Clients

 
574
            
Java
 
574
            
MapReduce
 
576
            
REST and Thrift
 
577
        

Building an Online Query Application

 
578
            
Schema Design
 
578
            
Loading Data
 
579
                
Load distribution
 
581
                
Bulk load
 
581
            
Online Queries
 
581
                
Station queries
 
582
                
Observation queries
 
583
        

HBase Versus RDBMS

 
585
            
Successful Service
 
585
            
HBase
 
586
        

Praxis

 
588
            
HDFS
 
588
            
UI
 
588
            
Metrics
 
588
            
Counters
 
589
        

Further Reading

 
590
    

21. ZooKeeper

 
591
        

Installing and Running ZooKeeper

 
594
        

An Example

 
596
            
Group Membership in ZooKeeper
 
596
            
Creating the Group
 
597
            
Joining a Group
 
598
            
Listing Members in a Group
 
599
                
ZooKeeper command-line tools
 
601
            
Deleting a Group
 
601
        

The ZooKeeper Service

 
603
            
Data Model
 
603
                
Ephemeral znodes
 
603
                
Sequence numbers
 
604
                
Watches
 
604
            
Operations
 
604
                
Multiupdate
 
605
                
APIs
 
605
                
Watch triggers
 
606
                
ACLs
 
607
            
Implementation
 
608
            
Consistency
 
609
            
Sessions
 
611
                
Time
 
612
            
States
 
613
        

Building Applications with ZooKeeper

 
615
            
A Configuration Service
 
615
            
The Resilient ZooKeeper Application
 
617
                
InterruptedException
 
617
                
KeeperException
 
618
                    State exceptions
 
618
                    Recoverable exceptions
 
618
                    Unrecoverable exceptions
 
619
                
A reliable configuration service
 
619
            
A Lock Service
 
620
                
The herd effect
 
621
                
Recoverable exceptions
 
621
                
Unrecoverable exceptions
 
622
                
Implementation
 
622
            
More Distributed Data Structures and Protocols
 
622
                
BookKeeper and Hedwig
 
622
        

ZooKeeper in Production

 
624
            
Resilience and Performance
 
624
            
Configuration
 
625
        

Further Reading

 
626

V. Case Studies

 
627
    

22. Composable Data at Cerner

 
629
        

From CPUs to Semantic Integration

 
631
        

Enter Apache Crunch

 
632
        

Building a Complete Picture

 
633
        

Integrating Healthcare Data

 
636
        

Composability over Frameworks

 
639
        

Moving Forward

 
640
    

23. Biological Data Science: Saving Lives with Software

 
641
        

The Structure of DNA

 
644
        

The Genetic Code: Turning DNA Letters into Proteins

 
645
        

Thinking of DNA as Source Code

 
647
        

The Human Genome Project and Reference Genomes

 
649
        

Sequencing and Aligning DNA

 
650
        

ADAM, A Scalable Genome Analysis Platform

 
651
            
Literate programming with the Avro interface description language (IDL)
 
651
            
Column-oriented access with Parquet
 
652
            
A simple example: k-mer counting using Spark and ADAM
 
654
        

From Personalized Ads to Personalized Medicine

 
656
        

Join In

 
657
    

24. Cascading

 
658
        

Fields, Tuples, and Pipes

 
660
        

Operations

 
663
        

Taps, Schemes, and Flows

 
665
        

Cascading in Practice

 
666
        

Flexibility

 
669
        

Hadoop and Cascading at ShareThis

 
670
        

Summary

 
674

A. Installing Apache Hadoop

 
675
    

Prerequisites

 
677
    

Installation

 
678
    

Configuration

 
679
        

Standalone Mode

 
679
        

Pseudodistributed Mode

 
680
            
Configuring SSH
 
680
            
Formatting the HDFS filesystem
 
681
            
Starting and stopping the daemons
 
681
            
Creating a user directory
 
681
        

Fully Distributed Mode

 
681

B. Cloudera’s Distribution Including Apache Hadoop

 
683

C. Preparing the NCDC Weather Data

 
686

D. The Old and New Java MapReduce APIs

 
689

Index

 
693

Colophon

 
778

Copyright

 
779