100% found this document useful (4 votes)
518 views65 pages

Spring Cloud Data Flow: Native Cloud Orchestration Services For Microservice Applications On Modern Runtimes 1st Edition Felipe Gutierrez

Native

Uploaded by

lorcadunayvy
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (4 votes)
518 views65 pages

Spring Cloud Data Flow: Native Cloud Orchestration Services For Microservice Applications On Modern Runtimes 1st Edition Felipe Gutierrez

Native

Uploaded by

lorcadunayvy
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 65

Download the Full Version of textbook for Fast Typing at textbookfull.

com

Spring Cloud Data Flow: Native Cloud Orchestration


Services for Microservice Applications on Modern
Runtimes 1st Edition Felipe Gutierrez

https://textbookfull.com/product/spring-cloud-data-flow-
native-cloud-orchestration-services-for-microservice-
applications-on-modern-runtimes-1st-edition-felipe-
gutierrez/

OR CLICK BUTTON

DOWNLOAD NOW

Download More textbook Instantly Today - Get Yours Now at textbookfull.com


Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Cloud Native Java Designing Resilient Systems with Spring


Boot Spring Cloud and Cloud Foundry 1st Edition Long

https://textbookfull.com/product/cloud-native-java-designing-
resilient-systems-with-spring-boot-spring-cloud-and-cloud-foundry-1st-
edition-long/
textboxfull.com

Spring Boot: Up and Running: Building Cloud Native Java


and Kotlin Applications Mark Heckler

https://textbookfull.com/product/spring-boot-up-and-running-building-
cloud-native-java-and-kotlin-applications-mark-heckler/

textboxfull.com

Spring Boot Messaging: Messaging APIs for Enterprise and


Integration Solutions Felipe Gutierrez

https://textbookfull.com/product/spring-boot-messaging-messaging-apis-
for-enterprise-and-integration-solutions-felipe-gutierrez/

textboxfull.com

Practical Process Automation Orchestration and Integration


in Microservices and Cloud Native Architectures 1st
Edition Ruecker Bernd
https://textbookfull.com/product/practical-process-automation-
orchestration-and-integration-in-microservices-and-cloud-native-
architectures-1st-edition-ruecker-bernd/
textboxfull.com
Cloud Native Data Center Networking 1st Edition Dinesh G.
Dutt

https://textbookfull.com/product/cloud-native-data-center-
networking-1st-edition-dinesh-g-dutt/

textboxfull.com

Programming Kubernetes Developing Cloud Native


Applications 1st Edition Michael Hausenblas

https://textbookfull.com/product/programming-kubernetes-developing-
cloud-native-applications-1st-edition-michael-hausenblas/

textboxfull.com

Kubernetes Patterns Reusable Elements for Designing Cloud


Native Applications 1st Edition Bilgin Ibryam

https://textbookfull.com/product/kubernetes-patterns-reusable-
elements-for-designing-cloud-native-applications-1st-edition-bilgin-
ibryam/
textboxfull.com

Cloud Native Go Building Reliable Services in Unreliable


Environments 1st Edition Matthew A Titmus

https://textbookfull.com/product/cloud-native-go-building-reliable-
services-in-unreliable-environments-1st-edition-matthew-a-titmus/

textboxfull.com

Cloud Native Go Building Reliable Services in Unreliable


Environments 1st Edition Titmus Matthew A

https://textbookfull.com/product/cloud-native-go-building-reliable-
services-in-unreliable-environments-1st-edition-titmus-matthew-a/

textboxfull.com
Spring Cloud
Data Flow
Native Cloud Orchestration Services
for Microservice Applications on
Modern Runtimes

Felipe Gutierrez
Spring Cloud Data Flow
Native Cloud Orchestration Services
for Microservice Applications on Modern
Runtimes

Felipe Gutierrez
Spring Cloud Data Flow: Native Cloud Orchestration Services for Microservice
Applications on Modern Runtimes
Felipe Gutierrez
Albuquerque, NM, USA

ISBN-13 (pbk): 978-1-4842-1240-0       ISBN-13 (electronic): 978-1-4842-1239-4 


https://doi.org/10.1007/978-1-4842-1239-4

Copyright © 2021 Felipe Gutierrez


This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol
with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only
in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are
not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publica-
tion, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors
or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Steve Anglin
Development Editor: Matthew Moodie
Coordinating Editor: Mark Powers
Cover designed by eStudioCalamar
Cover image designed by Freepik (www.freepik.com)
Distributed to the book trade worldwide by Apress Media, LLC, 1 New York Plaza, New York, NY 10004,
U.S.A. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.
springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer
Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected]; for reprint, paperback,
or audio rights, please e-mail [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to readers
on GitHub via the book’s product page, located at www.apress.com/9781484212400. For more detailed
information, please visit http://www.apress.com/source-code.
Printed on acid-free paper
In memory of my grandparents: Juan Gutierrez and Baciliza
Rivero and Simon Cruz and Elvira Galindo.
I love you and miss you guys!
Table of Contents

About the Author����������������������������������������������������������������������������������������������������� xi


About the Technical Reviewer������������������������������������������������������������������������������� xiii
Acknowledgments���������������������������������������������������������������������������������������������������xv


■Part I: Introductions��������������������������������������������������������������������������� 1

■Chapter 1: Cloud and Big Data������������������������������������������������������������������������������� 3
A Little Data Science�������������������������������������������������������������������������������������������������������� 3
The Cloud������������������������������������������������������������������������������������������������������������������������� 4
Cloud Technology and Infrastructure������������������������������������������������������������������������������������������������������ 5

The Right Tools����������������������������������������������������������������������������������������������������������������� 6


Summary�������������������������������������������������������������������������������������������������������������������������� 8

■Chapter 2: Spring Boot������������������������������������������������������������������������������������������ 9
What Is Spring Framework and What Is Spring Boot?����������������������������������������������������� 9
Spring Framework���������������������������������������������������������������������������������������������������������������������������������� 9
Spring Boot������������������������������������������������������������������������������������������������������������������������������������������� 21
Beyond the Directory App Example������������������������������������������������������������������������������������������������������ 24

Spring Boot Features������������������������������������������������������������������������������������������������������ 30


Summary������������������������������������������������������������������������������������������������������������������������ 31
■ Table of Contents


■Chapter 3: Spring Integration������������������������������������������������������������������������������ 33
Integration Patterns�������������������������������������������������������������������������������������������������������� 33
Messaging���������������������������������������������������������������������������������������������������������������������� 34
Spring Integration����������������������������������������������������������������������������������������������������������� 35
Movie App Specification Requirements������������������������������������������������������������������������������������������������ 35
Creating the Movie App: Part I�������������������������������������������������������������������������������������������������������������� 36
Creating a Movie App: Part II (External)������������������������������������������������������������������������������������������������ 52
Summary������������������������������������������������������������������������������������������������������������������������ 69

■Chapter 4: Spring Batch�������������������������������������������������������������������������������������� 71
Spring Batch������������������������������������������������������������������������������������������������������������������� 71
Programming Model����������������������������������������������������������������������������������������������������������������������������� 71
Spring Batch Features�������������������������������������������������������������������������������������������������������������������������� 72
Movie Batch App Using Declarative XML���������������������������������������������������������������������������������������������� 72
Movie Batch App Using JavaConfig������������������������������������������������������������������������������������������������������ 80

Summary������������������������������������������������������������������������������������������������������������������������ 87

■Chapter 5: Spring Cloud�������������������������������������������������������������������������������������� 89
Microservices����������������������������������������������������������������������������������������������������������������� 89
The Twelve-Factor App��������������������������������������������������������������������������������������������������� 90
Spring Cloud������������������������������������������������������������������������������������������������������������������� 92
Spring Cloud Config������������������������������������������������������������������������������������������������������������������������������ 92

Spring Cloud Netflix������������������������������������������������������������������������������������������������������ 111


Service Discovery: Eureka Service Registry��������������������������������������������������������������������������������������� 111
Circuit Breaker������������������������������������������������������������������������������������������������������������������������������������ 122

About Reactive Programming��������������������������������������������������������������������������������������� 126


Summary���������������������������������������������������������������������������������������������������������������������� 127

■Chapter 6: Spring Cloud Stream������������������������������������������������������������������������ 129
Spring Cloud Stream Application Starters�������������������������������������������������������������������� 129
HTTP Source | Log-Sink Example������������������������������������������������������������������������������������������������������� 130

vi
■ Table of Contents

Spring Cloud Stream���������������������������������������������������������������������������������������������������� 137


Movie Cloud Stream Using Kafka: movie-sink-kafka������������������������������������������������������������������������� 137
Movie Cloud Stream Using RabbitMQ: movie-sink-rabbit������������������������������������������������������������������� 141

Spring Cloud Stream���������������������������������������������������������������������������������������������������� 144


Spring Cloud Stream Features������������������������������������������������������������������������������������������������������������ 146
Programming Model��������������������������������������������������������������������������������������������������������������������������� 148
Producing and Consuming������������������������������������������������������������������������������������������������������������������ 166
Summary���������������������������������������������������������������������������������������������������������������������� 174

■Chapter 7: Spring Cloud Stream Binders����������������������������������������������������������� 175
Binder��������������������������������������������������������������������������������������������������������������������������� 175
Implementing a Binder����������������������������������������������������������������������������������������������������������������������� 177

NATS Binder����������������������������������������������������������������������������������������������������������������� 177


Project: nats-binder���������������������������������������������������������������������������������������������������������������������������� 177
NATS Client: nats-messaging������������������������������������������������������������������������������������������������������������� 179
NATS Binder Implementation: nats-messaging-binder���������������������������������������������������������������������� 186
NATS Binder Test�������������������������������������������������������������������������������������������������������������������������������� 194

Multiple Binders����������������������������������������������������������������������������������������������������������� 198


movie-file-source-nats����������������������������������������������������������������������������������������������������������������������� 198
movie-filter-processor-nats-rabbit����������������������������������������������������������������������������������������������������� 202
movie-log-sink-rabbit������������������������������������������������������������������������������������������������������������������������� 204
Running Them All Together����������������������������������������������������������������������������������������������������������������� 205
Extra Configuration����������������������������������������������������������������������������������������������������������������������������� 207

Summary���������������������������������������������������������������������������������������������������������������������� 207

■Chapter 8: Spring Cloud Data Flow: Introduction and Installation�������������������� 209
Spring Cloud Data Flow������������������������������������������������������������������������������������������������ 209
Features���������������������������������������������������������������������������������������������������������������������������������������������� 210

Local Installation���������������������������������������������������������������������������������������������������������� 211


Single Machine/Server����������������������������������������������������������������������������������������������������������������������� 211

Spring Cloud Data Flow Dashboard������������������������������������������������������������������������������ 215


Registering Cloud Stream Applications Starters��������������������������������������������������������������������������������� 216

vii
■ Table of Contents

Separated Server or a Proxy���������������������������������������������������������������������������������������� 219


Using Docker Compose������������������������������������������������������������������������������������������������ 220
Kubernetes Installation������������������������������������������������������������������������������������������������ 224
Personal Computer with Docker Desktop������������������������������������������������������������������������������������������� 224
Minikube��������������������������������������������������������������������������������������������������������������������������������������������� 226
Installing Spring Cloud Data Flow in Kubernetes������������������������������������������������������������������������������� 226

Testing Your Installation with a Simple Stream������������������������������������������������������������ 249


Using Docker Compose����������������������������������������������������������������������������������������������������������������������� 250
Using Kubernetes������������������������������������������������������������������������������������������������������������������������������� 258
Cleaning Up���������������������������������������������������������������������������������������������������������������������������������������� 261

Summary���������������������������������������������������������������������������������������������������������������������� 262


■Part II: Spring Cloud Data Flow: Internals�������������������������������������� 263

■Chapter 9: Spring Cloud Data Flow Internals���������������������������������������������������� 265
Spring Cloud Data Flow Architecture��������������������������������������������������������������������������� 265
Client Tools: cURL Command, Data Flow Shell, Java Client, Dashboard����������������������� 268
Using cURL, Httpie, and jq������������������������������������������������������������������������������������������������������������������ 271
Using Spring Cloud Data Flow Shell��������������������������������������������������������������������������������������������������� 279
Using the Dashboard�������������������������������������������������������������������������������������������������������������������������� 285
Creating the Stream Programmatically���������������������������������������������������������������������������������������������� 299

Summary���������������������������������������������������������������������������������������������������������������������� 310

■Chapter 10: Custom Stream Apps with Spring Cloud Data Flow����������������������� 311
Custom Stream Apps: A Quick Review������������������������������������������������������������������������� 311
Custom Stream Apps in Spring Cloud Data Flow��������������������������������������������������������� 312
Movie Web App: movie-source����������������������������������������������������������������������������������������������������������� 312
Movie IMDB App: movie-processor����������������������������������������������������������������������������������������������������� 319
Movie Log App: movie-sink����������������������������������������������������������������������������������������������������������������� 326
Packaging and Deploy Stream Apps��������������������������������������������������������������������������������������������������� 328
Registering Stream Apps�������������������������������������������������������������������������������������������������������������������� 331
Create and Deploy Custom Streams��������������������������������������������������������������������������������������������������� 335

Summary���������������������������������������������������������������������������������������������������������������������� 339
viii
■ Table of Contents


■Chapter 11: Task and Batch Apps with Spring Cloud Data Flow����������������������� 341
Spring Cloud Task Primer��������������������������������������������������������������������������������������������� 341
Simple Task Demo������������������������������������������������������������������������������������������������������������������������������ 342

Spring Cloud Stream Integration���������������������������������������������������������������������������������� 346


Task Events Within Spring Cloud Stream�������������������������������������������������������������������������������������������� 346
Launching Tasks in Spring Cloud Data Flow��������������������������������������������������������������������������������������� 348
Launching a Task Using Data Flow Shell�������������������������������������������������������������������������������������������� 361
Batch Processing��������������������������������������������������������������������������������������������������������� 362
Movie Batch���������������������������������������������������������������������������������������������������������������������������������������� 362
Launching a Task/Batch with a Stream in Data Flow������������������������������������������������������������������������� 368

Summary���������������������������������������������������������������������������������������������������������������������� 381

■Chapter 12: Monitoring������������������������������������������������������������������������������������� 383
Micrometer������������������������������������������������������������������������������������������������������������������� 383
Health Checks and Monitoring Stream Apps���������������������������������������������������������������� 385
Monitoring Task Apps��������������������������������������������������������������������������������������������������� 387
Movie Stream Pipeline DSL: Putting It All Together������������������������������������������������������ 388
Stream Pipeline DSL��������������������������������������������������������������������������������������������������������������������������� 391
Task Creating�������������������������������������������������������������������������������������������������������������������������������������� 393
Stream Deployment���������������������������������������������������������������������������������������������������������������������������� 393

Summary���������������������������������������������������������������������������������������������������������������������� 397

■Index������������������������������������������������������������������������������������������������������������������ 399

ix
About the Author

Felipe Gutierrez is a cloud solutions software architect, with a bachelor’s degree and a master’s degree in
computer science from Instituto Tecnólogico y de Estudios Superiores de Monterrey, Ciudad de Mexico.
With more than 25 years of IT experience, he has developed programs for companies in multiple vertical
industries, including government, retail, health care, education, and banking. Currently, he works as a senior
cloud application architect for IBM, specializing in Red Hat OpenShift, IBM Cloud, app modernization,
Cloud Foundry, Spring Framework, Spring Cloud Native applications, Groovy, and RabbitMQ, among other
technologies. He has worked as a solutions architect for companies like VMware, Nokia, Apple, Redbox, and
Qualcomm. Felipe is the author of Introducing Spring Framework (Apress, 2014), Pro Spring Boot (Apress,
2016), and Spring Boot Messaging (Apress, 2017).
About the Technical Reviewer

Manuel Jordan Elera is an autodidactic developer and researcher who


enjoys learning new technologies for his own experiments and creating
new integrations. Manuel won the Springy Award—Community
Champion and Spring Champion 2013. In his little free time, he reads the
Bible and composes music on his guitar. Manuel is known as dr_pompeii.
He has tech-reviewed numerous books for Apress, including Pro Spring,
4th Edition (2014), Practical Spring LDAP (2013), Pro JPA 2, Second Edition
(2013), and Pro Spring Security (2013). You can read his 13 detailed
tutorials about many Spring technologies and contact him through his
blog at www.manueljordanelera.blogspot.com, and follow him on his
Twitter account, @dr_pompeii.
Acknowledgments

I would like to express all my gratitude to the Apress team: Steve Anglin for accepting my proposal, Mark
Powers for keeping me on track and for his patience, and the rest of the Apress team involved in this project.
Thanks to everybody for making this possible.
Thanks to my technical reviewer, Manuel Jordan, for all the details and effort in his reviews, and the
entire Spring team for creating this amazing technology.
I want to dedicate this book to my grandparents: Juan Gutierrez and Baciliza Rivero on my dad’s side,
and Simon Cruz and Elvira Galindo on my mom’s side. Thanks for being part of my life. I miss you so much.
—Felipe Gutierrez
PART I

Introductions
CHAPTER 1

Cloud and Big Data

The digital universe consists of an estimated 44 zettabytes of data. A zettabyte is 1 million petabytes, or
1 billion terabytes, or 1 trillion gigabytes. In 2019, Google processed approximately 3.7 million queries,
YouTube recorded 4.5 million viewed videos, and Facebook registered 1 million logins every 60 seconds.
Imagine the computer power to process all these requests, data ingestion, and data manipulation. Common
sense tells us that the big IT companies use a lot of hardware to preserve data. A lot of storage needs to be
incorporated to prevent limits of capacity.
How does an IT company deal with challenges like data overload, rising costs, or skill gaps? In recent
years, big IT companies have heavily invested in developing strategies that use enterprise data warehouses
(EDW) to serve as central data systems that report, extract, transform, and load (ETL) processes from
different sources. Today, both users and devices (thermostats, light bulbs, security cameras, coffee
machines, doorbells, seat sensors, etc.) ingest data.
Companies such as Dell, Intel, and Cloudera—to name a few—work together to create hardware and
storage solutions that help other companies grow and become faster and more scalable.

A Little Data Science


When we talk about data science, a team of scientists with PhD degrees comes to mind. They probably
earn big bucks, and they don’t rest because companies depend on them. What is a data scientist’s actual
educational experience?
A few years ago, computing journals revealed that Spark and Scala skyrocketed in companies that
wanted to apply data science with the addition of tools such as Hadoop, Kafka, Hive, Pig, Cassandra, D3, and
Tableau.
Python has become one of the main programming languages for machine learning techniques,
alongside R, Scala, and Java.
Machine learning normally works in business, math, computer science, and communication. Data
scientists use data for predictions, classification, recommendations, pattern detection and grouping,
anomaly detection, recognition, actionable insights, automated processes, decision-making, scoring and
ranking, segmentation, optimization, and forecasts. That’s a lot!

© Felipe Gutierrez 2021 3


F. Gutierrez, Spring Cloud Data Flow, https://doi.org/10.1007/978-1-4842-1239-4_1
Chapter 1 ■ Cloud and Big Data

Figure 1-1. Data science

We need to have the right tools, platform, infrastructure, and software engineering knowledge to
innovate and create. Machine learning should rely on a programming language that feels comfortable
and easy to learn (like Python). The platform should have the right engines for processing the data. The
infrastructure should be reliable, secure, and redundant. The development techniques should create
awesome enterprise solutions that benefit not only the company but all its users around the world.

The Cloud
Over the past decade, many companies have gone into the so-called cloud, or they are cloud native, or they
are in the cloud computing era; but what does that even mean? Several companies have said that they were
always in the cloud because all their services live outside the company, managed by a third party, and they
have faster responses if there is an outage. But is that accurate? Or does cloud mean architectural computing
in which servers, networks, storage, development tools, and applications are enabled through the Internet?
In my opinion, we have Internet access through a public cloud environment, where users can “plug
into” data and applications at any given time and place through an Internet connection. I see the cloud as
a new measure service with a pay-as-you-go model, where you only pay for what you are using, from any
server, network, storage, bandwidth, application, or more—very similar to an electric or water company that
charges based on consumption.
4
Chapter 1 ■ Cloud and Big Data

I also see the cloud as an on-demand self-service. You can request any of those services, and they are
provisioned very quickly with a few clicks.
I can see the cloud as a multitenancy model where a single instance of an application, network, or
server is shared across multiple users. This is referred to as shared resource pooling. Once you finish using it,
it returns to the pool to wait for another user to request it.
I can see the cloud as an elastic platform where the resources quickly scale up or down as needed (see
Figure 1-2).

Figure 1-2. Cloud computing

Cloud Technology and Infrastructure


I think that today cloud technology means that companies can be scalable and adapt at speed. They can
accelerate innovation, drive business agility more efficiently, streamline operations with confidence, and
reduce costs to better compete with other companies. This leads companies to increased sustainable
growth. Today, companies that are more strategic in their approach to technology are doing better
financially, but how do these companies view new cloud technology?
Big IT companies like Amazon (the pioneer of on-demand computing), Google, and Microsoft offer
cloud technology. These companies are well paid to provide companies a cloud infrastructure that delivers
elasticity, managed services, on-demand computing and storage, networking, and more.

5
Chapter 1 ■ Cloud and Big Data

Storage, servers, or VMs are needed to implement cloud infrastructure. Managed services, hybrid
operations, and data security and management are also required. Services that allow the companies to use
their data against all these new machine learning tools and apply new artificial intelligence algorithms for
system analytics to help with fraud detection help with decision making, to name a few growing features of
data processing (see Figure 1-3).

Figure 1-3. Cloud infrastructure

The Right Tools


In my 20 years of experience, I’ve seen big companies use tools and technologies that help them use
collected data in the right way and to follow best practices and standards for data manipulation. Due to all
new requirements and the way the demand for services increase, companies hire people who know how to
use tools such as JMS, RabbitMQ, Kinesis, Kafka, NATs, ZeroMQ, ActiveMQ, Google PubSub, and others. We
see more message patterns emerge with these technologies, such as event-driven or data-driven patterns
(see Figure 1-4). These patterns aren’t new, but they haven’t received much attention until now.

6
Chapter 1 ■ Cloud and Big Data

Figure 1-4. Data-driven enterprise

Technologies like Apache Hadoop distribute large data sets across clusters. Apache Flume is a simple
and flexible architecture for streaming dataflows and a service for collecting, aggregating, and moving large
amounts of log data. Apache Sqoop is a batch tool for transferring bulk data between Apache Hadoop and
structured datastores (such as relational databases); it solves some of the data wrangling that you need to do.
A new wave of programming languages can process a large amount of data. These include languages
like R, Python, and Scala, and a set of libraries and frameworks, like MadLib, for machine learning and
expert systems (see Figures 1-5 and 1-6).

Figure 1-5. Data streaming

Figure 1-6. Data stream

New protocols for messaging brokers emerge every day. Should we learn all these new technologies?
Or should we hire people with all these skill sets? I think we should at least have a technology that takes care
of communication. Well, we do: Spring Cloud Stream and the orchestrator, Spring Cloud Data Flow (see
Figure 1-7).

7
Chapter 1 ■ Cloud and Big Data

I’ll discuss these two technologies. If you are a Spring developer, you don’t need to learn any new APIs
for messaging; you can work with what you already know—Java and Spring. If you are new to Spring, in the
next two chapters, I give a quick tour of Spring Boot, Spring Integration, and Spring Batch and show you how
to use them. These three technologies are the core of Spring Cloud Stream and Spring Cloud Data Streams
(see Figure 1-7).
Next, you create your first Stream applications, which can connect regardless of the messaging broker.
That’s right; it doesn’t matter which broker you set up between multiple Streams apps. Spring Cloud Stream
has that capability. You will develop custom streams and create a custom binder that allows you to hide any
API from a messaging broker.
Finally, I talk about Spring Cloud Data Flow and its components and how to create apps, streams, and
tasks and monitor them (see Figure 1-7).

Figure 1-7. Data stream: Spring Cloud Data Flow

S
 ummary
In this chapter, I talked about big data and new ways to improve services using cloud infrastructures that
offer out-of-the-box solutions. Every company needs to have visibility, speed, the ability to enter the market
quickly, and time to react.
In this short chapter, I wanted to set the context for this book. In the next chapters, I talk about
technologies that help you use big data to create enterprise-ready solutions.

8
CHAPTER 2

Spring Boot

One way to build cloud-native applications is to follow the Twelve-Factor App guidelines
(https://12factor.net) that facilitate running applications in any cloud environment. Some of these
principles, like dependencies declaration (factor II), configuration (factor III), and port binding (factor VII),
among others, are supported by Spring Boot! Spring Boot is a microservice and cloud-ready framework.
Why Spring Boot and not just Spring? Or maybe another technology, like NodeJS or the Go language?
Spring Boot is a technology that has no comparison because is backed by the most-used framework in the
Java community and lets you create an enterprise-ready application with ease. Other languages require
you to do a lot of manual setup and coding. Spring Boot provides it for you. Even though technologies like
NodeJS have hundreds of libraries, it is no match at the enterprise level like Spring, in my opinion. Don’t get
me wrong. I’m not saying that other technologies are bad or not useful, but if you want to build a fast, fine-
grained, enterprise application, only Spring Boot offers minimal configuration and code. Let’s look at why
Spring Boot is important and how it helps you create cloud-native applications.

What Is Spring Framework and What Is Spring Boot?


Spring Boot is the next generation of Spring applications. It is an opinionated runtime technology that
exposes the best practices for creating enterprise-ready Spring applications.

Spring Framework
Let’s back up a little bit and talk about the Spring Framework. With the Spring Framework, you can
create fine-grained enterprise apps, but you need to know how it works, and most importantly, how
to configure it. Configuration is one of the key elements of the Spring Framework. You can decouple
custom implementations, DB connections, and calls to external services, making Spring Framework more
extensible, easy to maintain, and run. At some point, you need to know all the best practices to apply to a
Spring app. Let’s start with a simple Spring app that demonstrates how the Spring Framework works.

A
 Directory Application
Let’s suppose that you need to create a Spring application that saves people’s contact information, such as
names, emails, and phone numbers. It is a basic directory app that exposes a REST API with persistence in
any DB engine, and it can be deployed in any compliant J2EE server. The following are the steps to create
such an application.

© Felipe Gutierrez 2021 9


F. Gutierrez, Spring Cloud Data Flow, https://doi.org/10.1007/978-1-4842-1239-4_2
Chapter 2 ■ Spring Boot

1. Install a building tool like Maven or Gradle to compile and build the source
code’s directory structure. If you come from a Java background, you know that
you need a WEB-INF directory structure for this app.
2. Create web.xml and application-context.xml files. The web.xml file has the
org.springframework.web.servlet.DispatcherServlet class, which acts as a
front controller for Spring-based web applications.
3. Add a listener class that points to the application-context.xml file, where you
declare all the Spring beans or any other configuration needed for your app. If
you omit the listener section, you need to name your Spring beans declaration
file the same as the DispatcherServlet.
4. In the application-context.xml file, add several Spring beans sections to
cover every detail. If you are using JDBC, you need to add a datasource, init SQL
scripts, and a transaction manager. If you are using JPA, you need to add a JPA
declaration (a persistence.xml file where you configure your classes and your
primary unit) and an entity manager to handle sessions and communicate with
the transaction manager.
5. Because this is a web app, it is necessary to add some Spring beans sections
in the application-context.xml file about HTTP converters that expose
JSON views and MVC-driven annotations to use the @RestController and
@RequestMapping (or @GetMapping, @PostMapping, @DeleteMapping, etc.)
among other Spring MVC annotations.
6. If you are using JPA (the easiest way to do persistence with minimal effort),
specify the repositories and the classes’ location with the
@EnableJpaRepositories annotation.
7. To run the app, package your application in a WAR format. You need to install an
application server that is compliant with J2EE standards and then test it.
If you are an experienced Spring developer, you know what I’m talking about. If you are a newbie, then
you need to learn all the syntax. It’s not too difficult, but you need to spend some time on it. Or perhaps there is
another way. Of course, there is. You can use annotation-based configuration or a JavaConfig class to set up the
Spring beans, or you can use a mix of both. In the end, you need to learn some of the Spring annotations that
help you configure this app. You can review the source code (ch02/directory-jpa) on this book’s web site.
Let’s review some of this application’s code. Remember, you need to create a Java web structure (see
Figure 2-1).

Figure 2-1. A Java web-based directory structure


10
Chapter 2 ■ Spring Boot

Figure 2-1 shows a Java web-based directory structure. You can delete the index.jsp file, open the web.
xml file, and replace it all with the content shown in Listing 2-1.

Listing 2-1. web.xml


<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/application-context.xml</param-value>
  </context-param>

  <servlet>
    <servlet-name>app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value></param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>app</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

Listing 2-1 shows you how to add a Spring servlet (DispatcherServlet, a front controller pattern) that is
the main servlet to attend any request from the user.
Next, let’s create the application-context.xml file by adding the content in Listing 2-2.

Listing 2-2. application-context.xml


<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.


w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:tx="http://www.springframework.org/schema/tx"

11
Chapter 2 ■ Spring Boot

       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/
spring-mvc.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/
spring-tx.xsd
        http://www.springframework.org/schema/jdbc https://www.springframework.org/schema/
jdbc/spring-jdbc.xsd
        http://www.springframework.org/schema/data/jpa https://www.springframework.org/
schema/data/jpa/spring-jpa.xsd
                http://www.springframework.org/schema/beans http://www.springframework.org/
schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context http://www.springframework.
org/schema/context/spring-context.xsd">

     <mvc:annotation-driven />
     <tx:annotation-driven />
     <jpa:repositories base-package="com.apress.spring.directory.repository" entity-manager-
factory-ref="localContainerEntityManagerFactoryBean" />
     <context:component-scan base-package="com.apress.spring.directory" />

     <mvc:annotation-driven content-negotiation-manager="contentNegotiationManager">
          <mvc:message-converters>
               <bean class="org.springframework.http.converter.json.
MappingJackson2HttpMessageConverter">
                    <property name="objectMapper" ref="objectMapper"/>
               </bean>
               <bean class="org.springframework.http.converter.xml.
MappingJackson2XmlHttpMessageConverter">
                    <property name="objectMapper" ref="xmlMapper"/>
               </bean>
          </mvc:message-converters>
     </mvc:annotation-driven>

     <bean id="objectMapper" class="org.springframework.http.converter.json.


Jackson2ObjectMapperFactoryBean">
          <property name="indentOutput"  value="true"/>
          <property name="modulesToInstall" value="com.fasterxml.jackson.module.paramnames.
ParameterNamesModule"/>
     </bean>

     <bean id="xmlMapper" parent="objectMapper">


          <property name="createXmlMapper" value="yes"/>
     </bean>

     <bean id="contentNegotiationManager" class="org.springframework.web.accept.


ContentNegotiationManagerFactoryBean">
          <property name="mediaTypes">
               <value>
                    json=application/json
                    xml=application/xml

12
Chapter 2 ■ Spring Boot

               </value>
          </property>
     </bean>

     <bean id="localContainerEntityManagerFactoryBean"
           class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
          <property name="dataSource" ref="dataSource" />
          <property name="jpaVendorAdapter">
               <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
          </property>
          <property name="jpaProperties">
               <props>
                    <prop key="hibernate.hbm2ddl.auto">create-drop</prop>
                    <prop key="hibernate.dialect">org.hibernate.dialect.H2Dialect</prop>
               </props>
          </property>
     </bean>

     <bean id="dataSource"
           class="org.springframework.jdbc.datasource.DriverManagerDataSource">
          <property name="driverClassName" value="org.h2.Driver" />
          <property name="url" value="jdbc:h2:mem:testdb" />
          <property name="username" value="sa" />
          <property name="password" value="" />
     </bean>

     <bean id="transactionManager" class="org.springframework.orm.jpa.


JpaTransactionManager">
          <property name="entityManagerFactory" ref="localContainerEntityManagerFactoryBean" />
     </bean>

     <bean id="persistenceExceptionTranslationPostProcessor" class=


             "org.springframework.dao.annotation.
PersistenceExceptionTranslationPostProcessor" />

     <jdbc:embedded-database type="H2" >


          <jdbc:script location="classpath:META-INF/sql/schema.sql"/>
          <jdbc:script location="classpath:META-INF/sql/data.sql"/>
     </jdbc:embedded-database>
</beans>

Listing 2-2 shows the application-context.xml file, in which you add all the necessary configuration
for the Spring container, which is where all your classes are initialized and wired up.
Before reviewing each tag and the way it is declared, see if you can guess what each does and why it is
configured the way it is. Look at the naming and references between declarations.
If you are new to Spring, I recommend you look at the Pro Spring series published by Apress. These
books explain every aspect of this declarative form of configuring Spring.
Next, add the following classes: Person, PersonRepository, and PersonController, respectively (see
Listings 2-3, 2-4, and 2-5).

13
Chapter 2 ■ Spring Boot

Listing 2-3. com.apress.spring.directory.domain.Person.java


package com.apress.spring.directory.domain;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Person {

    @Id
    private String email;
    private String name;
    private String phone;

    public Person() {
    }

    public Person(String email, String name, String phone) {


        this.email = email;
        this.name = name;
        this.phone = phone;
    }

    public String getEmail() {


        return email;
    }

    public void setEmail(String email) {


        this.email = email;
    }

    public String getName() {


        return name;
    }

    public void setName(String name) {


        this.name = name;
    }

    public String getPhone() {


        return phone;
    }

    public void setPhone(String phone) {


        this.phone = phone;
    }
}

Listing 2-3 shows the Person class that uses all the JPA (Java Persistence API) annotations, so it’s easy to
use, and no more direct JDBC.

14
Chapter 2 ■ Spring Boot

Listing 2-4. com.apress.spring.directory.repository.PersonRepository.java


package com.apress.spring.directory.repository;

import com.apress.spring.directory.domain.Person;
import org.springframework.data.repository.CrudRepository;

public interface PersonRepository extends CrudRepository<Person,String> {


}

Listing 2-4 shows the PersonRepository interface that extends from another CrudRepository interface.
Here it uses all the power of Spring Data and Spring Data JPA to create a repository pattern based on the
entity class and its primary key (in this case, a String type). In other words, there is no need to create any
CRUD implementations—let Spring Data and Spring Data JPA take care of that.

Listing 2-5. com.apress.spring.directory.controller.PersonController.java


package com.apress.spring.directory.controller;

import com.apress.spring.directory.domain.Person;
import com.apress.spring.directory.repository.PersonRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;

@Controller
public class PersonController {

    private Logger log = LoggerFactory.getLogger(PersonController.class);


    private PersonRepository personRepository;

    public PersonController(PersonRepository personRepository) {


        this.personRepository = personRepository;
    }

    @RequestMapping(value = "/people",
            method = RequestMethod.GET,
            produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
    @ResponseBody
    public Iterable<Person> getPeople() {
        log.info("Accessing all Directory people...");
        return personRepository.findAll();
    }

15
Chapter 2 ■ Spring Boot

    @RequestMapping(value = "/people",
            method = RequestMethod.POST,
            consumes = MediaType.APPLICATION_JSON_VALUE,
            produces = {MediaType.APPLICATION_JSON_VALUE})
    @ResponseBody
    public ResponseEntity<?> create(UriComponentsBuilder uriComponentsBuilder,
@RequestBody Person person) {
        personRepository.save(person);

        UriComponents uriComponents =
                uriComponentsBuilder.path("/people/{id}").buildAndExpand(person.getEmail());

        return ResponseEntity.created(uriComponents.toUri()).build();
    }

    @RequestMapping(value = "/people/search",
            method = RequestMethod.GET,
            consumes = MediaType.APPLICATION_JSON_VALUE,
            produces = {MediaType.APPLICATION_JSON_VALUE})
    @ResponseBody
    public ResponseEntity<?> findByEmail(@RequestParam String email) {
        log.info("Looking for {}", email);
        return ResponseEntity.ok(personRepository.findById(email).orElse(null));
    }

    @RequestMapping(value = "/people/{email:.+}",
            method = RequestMethod.DELETE)
    @ResponseBody
    public ResponseEntity<?> deleteByEmail(@PathVariable String email) {
        log.info("About to delete {}", email);
        personRepository.deleteById(email);
        return ResponseEntity.accepted().build();
    }
}

Listing 2-5 shows the implementation of the PersonController class for any user request/response.
There are many ways to implement a web controller in Spring, such as using @RestController. Avoid writing
@ResponseBody in each method, or use dedicated annotations like @GetMapping, @PostMapping, and
@DeleteMapping instead of @RequestMapping.
Next, create the SQL files that initialize the database (see Listings 2-6 and 2-7).

Listing 2-6. META-INF/sql/schema.sql


CREATE TABLE person (
   email VARCHAR(100) NOT NULL PRIMARY KEY,
   name VARCHAR(100) NOT NULL,
   phone VARCHAR(20) NOT NULL,
);

Listing 2-6 is a simple schema that consists of only one table.

16
Chapter 2 ■ Spring Boot

Listing 2-7. META-INF/sql/data.sql


INSERT INTO person (email,name,phone) VALUES('[email protected]','Mark','1-800-APRESS');
INSERT INTO person (email,name,phone) VALUES('[email protected]','Steve','1-800-APRESS');
INSERT INTO person (email,name,phone) VALUES('[email protected]','Dan','1-800-APRESS');

Listing 2-7 shows a few records to insert when the app starts up. Next, because this app is using JPA,
it is necessary to provide a persistence.xml file. There is another option—you can add a bean declaration to
application-context.xml and declare the persistence unit required for the JPA engine to work (see Listing 2-8).

Listing 2-8. META-INF/persistence.xml


<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.
org/xml/ns/persistence/persistence_2_2.xsd">
    <!-- Define persistence unit -->
    <persistence-unit name="directory">
    </persistence-unit>
</persistence>

Listing 2-8 shows the required JPA file to declare the persistence unit. You can declare this as a property
in the localContainerEntityManagerFactoryBean bean declaration (persistenceUnitName property).
Next is one of the most important files. This app was created using Maven as a building tool. Let’s create
a pom.xml file at the root of the project (see Listing 2-9).

Listing 2-9. pom.xml


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/
maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.apress.spring</groupId>
  <artifactId>directory-jpa</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>directory-web-project Maven Webapp</name>
  <url>http://maven.apache.org</url>

  <properties>

    <java.version>1.8</java.version>
    <servlet.version>3.1.0</servlet.version>
    <spring-framework.version>5.2.2.RELEASE</spring-framework.version>
    <spring-data.jpa>2.2.3.RELEASE</spring-data.jpa>
    <slf4j.version>1.7.25</slf4j.version>
    <logback.version>1.2.3</logback.version>
    <h2>1.4.199</h2>
    <jackson>2.10.1</jackson>
  </properties>

  <dependencies>

17
Chapter 2 ■ Spring Boot

    <!-- Spring Core/MVC/Web -->


    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring-framework.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-jpa</artifactId>
      <version>${spring-data.jpa}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>${logback.version}</version>
    </dependency>

    <!-- Other Web dependencies -->


    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- JPA -->


    <dependency>
      <groupId>jakarta.activation</groupId>
      <artifactId>jakarta.activation-api</artifactId>

18
Random documents with unrelated
content Scribd suggests to you:
comuni in tutte le isole della Malesia e che le eleganti malesi
racchiudono in bolle di vetro, puntandosele fra i capelli con dei
bellissimi spilloni d’argento.
Era già trascorsa un’ora senza che fosse accaduto alcunchè di
straordinario, quando Cornelio credette di vedere una massa oscura
attraversare rapidamente il fiume, descrivendo una parabola assai
allungata. Si era staccata da un grande albero situato sulla sponda
destra ed era scomparsa sotto i boschi della sponda opposta.
— Wan-Horn, hai veduto? chiese, raccogliendo precipitosamente il
fucile.
— Non ho veduto nulla, nè udito nulla, signor Cornelio, rispose il
marinaio.
— M’è passata dinanzi agli occhi una cosa nera, che non ho potuto
ben distinguere.
— Sarà stato un uccello.
— No, Wan-Horn, era grosso assai e non aveva le forme d’un
volatile.
— Cosa volete che sia?
— Non lo so, ma se fosse qualche proiettile inviatoci dai papuasi?
— Non fanno uso che di freccie e di lancie, signor Cornelio...
— Lo so, ma... guarda!
Una massa nera, un’altra senza dubbio, si era staccata da un albero
della sponda destra, aveva attraversato il fiume con uno strano
dondolìo, producendo una lieve corrente d’aria ed era scomparsa fra
le piante dell’opposta riva.
— L’hai veduta, Horn? chiese Cornelio.
— Sì, e so cos’era.
— Un proiettile?
— No, signor Cornelio, era uno di quei volatili che i malesi chiamano
kubung, noi gatti o volpi volanti e gli scienziati galeopithecus, se non
erro.
— Che animali sono?
— Sembrano scimmie, più che volpi; sono alte mezzo metro, con
una testa piuttosto piccola che rassomiglia un po’ a quella degli
scoiattoli, col pelo rosso-oscuro, e spiccano delle vere volate di
sessanta metri. Ve ne sono pure delle altre che hanno una coda
lunga un buon piede, ma spiccano dei voli meno lunghi.
— Ma come fanno a volare?
— Colle ali.
— Delle scimmie colle ali? Ma tu sogni, Horn.
— No, signor Cornelio, ma non vi dico che le loro ali siano uguali a
quelle degli uccelli, tutt’altro. Hanno una specie di membrana che
parte dalle zampe anteriori, si unisce a quelle posteriori e si prolunga
fino alla coda. Agitando in fretta le zampe, agitano pure quella
membrana e spiccano la volata, ma come dissi, non si reggono per
più di sessanta od ottanta metri.
— E ve ne sono in quest’isola?
— Ne ho vedute molte nel porto di Dori e nei boschi della baia di
Geelwinc.
— Taci!
— Ancora?
— Ma questa non è una scimmia volante.
Tesero gli orecchi rattenendo il respiro e udirono, verso l’alto corso
del fiume, un tonfo che pareva prodotto dalla caduta di un corpo
pesante. Guardarono in quella direzione, ma l’ombra dei boschi era
così cupa che non riuscirono a distinguere nulla.
— Hai udito, Horn?
— Sì, signor Cornelio, rispose il marinaio, che era diventato inquieto.
— Che qualcuno si sia tuffato nel fiume?
— Lo temo.
— Qualche pirata forse?
— Ma i pirati devono venire dalla parte della foce.
— È vero, ma possono aver preso terra per sorprenderci d’ambe le
parti.
Wan-Horn non rispose, ma crollò il capo come non prestasse fede.
— Cosa facciamo? chiese Cornelio, dopo alcuni istanti di silenzio.
— Sorvegliamo le acque, per ora. Se è un uomo, bisognerà che salga
sul banco di sabbia per giungere fino a noi e si scoprirà, non
essendoci acqua intorno a noi.
— È vero... to’!... un altro tonfo!...
— Ed un altro più lontano.
— Che siamo circondati?...
— Oh!... esclamò il marinaio. Guardate laggiù!...
Cornelio guardò nella direzione indicata e distinse, a fior d’acqua,
delle masse nerastre, assai lunghe, che s’avvicinavano lentamente
verso il banco di sabbia facendo gorgogliare la corrente.
— Dei canotti? chiese egli, alzandosi.
— O dei coccodrilli? disse il marinaio.
— Ve ne sono qui?...
— Su tutti i fiumi.
— Che vogliano assalirci?... Fortunatamente siamo sulla scialuppa.
— Ma arenati in mezzo ad un banco, signor Cornelio, e nell’assoluta
impossibilità di fuggire verso le sponde. Se giungono qui, non
avranno difficoltà a entrare nella scialuppa e fors’anche a sfondarla
colle loro formidabili code.
— Svegliamo mio zio, Horn.
— Tutti, signor Cornelio; stiamo per passare un brutto quarto d’ora.
Il capitano ed i suoi compagni furono tosto svegliati e messi al fatto
di ciò che stava per accadere.
— La faccenda può diventare grave, disse Wan-Stael. I coccodrilli dei
fiumi della Nuova Guinea sono feroci, e non temono l’uomo.
Comincia a salire la marea?
— Da un quarto d’ora, rispose Wan-Horn.
— Bisogna difenderci finchè ci rimetterà a galla.
— Ed i pirati non udranno le fucilate?
— Senza dubbio, Horn, e saliranno il fiume, ma non possiamo
lasciarci divorare per evitare il loro ritorno. Appena potremo
muoverci, ci salveremo nei boschi. Attenti che i coccodrilli arrivano, e
badate a scaricare le armi nelle loro gole o le palle si schiaccieranno
sulle loro robuste scaglie.
I coccodrilli infatti giungevano, ma non erano due o tre, ma una vera
banda, trenta, quaranta e forse di più. Come si erano radunati colà
tanti sauriani, mentre i naufraghi non ne avevano veduto nemmeno
uno durante il giorno? Provenivano forse da qualche grande palude o
da qualche lago situato più oltre, verso la sorgente di quel corso
d’acqua? Era probabile.
Quegli spaventevoli anfibi, accortisi della presenza di grosse prede,
giungevano da tutte le parti, circondando il banco.
Alla luce degli astri si scorgevano le loro enormi mascelle irte di
lunghi denti, le quali si richiudevano con un fracasso analogo a
quello che produce un cassone quando viene lasciato cadere il
coperchio.
Le loro code sferzavano l’acqua con impeto irresistibile, sollevando
delle vere ondate, e nell’urtarsi si udivano le scaglie risuonare come
piastre d’osso vuote.
Circondato il banco, s’arrestarono, come se volessero prima
assicurarsi di che specie era la preda che stavano per assalire, poi
uno, il più audace ed il più lungo, poichè misurava almeno nove
metri, con un poderoso colpo di coda si issò sul banco che la marea
a poco a poco copriva e marciò dritto verso la scialuppa.
— È orribile! esclamò Hans rabbrividendo.
— Coraggio, ragazzi! disse il capitano, che non perdeva la sua calma.
Questo è mio.
Il sauriano non era che a sei passi: con un colpo di coda poteva
lanciarsi contro la scialuppa.
Wan-Stael puntò freddamente il fucile e fece fuoco fra le mascelle
spalancate del mostro.
Questi, colpito a morte dalla palla che doveva avergli attraversato il
corpo dalla gola alla coda, si raddrizzò come un cavallo che
s’impenna, vibrando uno spaventevole colpo di coda, poi ricadde,
contorcendosi furiosamente, sollevando dei larghi sprazzi di fango.
Gli altri, lungi dallo spaventarsi alla detonazione che per loro doveva
riuscire nuova, non adoperando i papuasi armi da fuoco, nè per la
morte del loro compagno, balzarono sul banco precipitandosi verso
la scialuppa.
— Coraggio! ripetè un’ultima volta il capitano, che caricava
precipitosamente il fucile.
L’assalto fu tremendo. Quei formidabili sauriani, credendo forse che
anche la scialuppa fosse una preda da inghiottire, si arrampicavano
l’un sull’altro per giungere primi ad afferrare i bordi. I loro aliti caldi e
fetenti giungevano fino in volto ai disgraziati naufraghi.
Questi però, malgrado fossero terrorizzati, non erano rimasti
inoperosi. Scaricate le armi sui più vicini, avevano afferrate le scuri, i
ramponi e perfino i remi e si difendevano con sovrumana energia,
picchiando furiosamente sui crani e sulle mascelle, spezzando i denti
o lacerando le gole di quei mostri.
Fortunatamente la scialuppa era alta di bordo ed i coccodrilli non
potevano superarla e rovesciarsi nell’interno, ma cercavano di
riuscirvi colle code o di sfasciarla tentando di azzannarla. Wan-Horn
e il capitano, armati di scure, non li lasciavano avvicinarsi troppo, e
ogni testa che appariva sui bordi ricadeva fracassata, mentre Hans e
Cornelio, ritti sui banchi, avevano riprese le armi, scaricandole in
quelle enormi gole.
Quella difesa accanita, quelle detonazioni, quei lampi, quelle grida
parvero sconcertare gli assalitori, i quali si decisero a retrocedere
verso i margini del banco, ma senza abbandonarlo però.
Cinque di loro giacevano distesi sulla sabbia e altri tre, feriti
gravemente, fors’anche mortalmente, si dibattevano in preda a
spaventevoli convulsioni.
I naufraghi, ripresi i fucili, avevano ricominciato il fuoco. Incoraggiati
dal primo successo, cercavano ora di respingere nel fiume i sauriani,
i quali, invece, parevano più propensi a rinnovare l’assalto.
— Non perdete colpo, disse il capitano. Se possiamo resistere ancora
dieci minuti, la scialuppa lascerà il banco.
— È già tutto coperto, disse Cornelio. La marea monta rapidamente.
— Ma quei coccodrilli non si decidono ad andarsene, disse Wan-
Horn. Ecco un altro che torna all’assalto.
— A voi, ragazzi! gridò il capitano.
Due spari echeggiarono formando quasi una sola detonazione. Il
sauriano fece uno scarto che lo portò sull’orlo del banco, poi rotolò
nel fiume scomparendo sott’acqua.
Gli altri, che parevano indecisi, retrocessero, ma poi tornarono
all’assalto urtandosi e accavallandosi confusamente, decisi a finirla
colle prede umane. Già stavano per raggiungere la scialuppa quando
questa, che da qualche istante subiva delle oscillazioni, sollevata
dalla marea, si spostò fuggendo attraverso al banco.
— Galleggiamo! gridò Cornelio.
— Ai remi, Horn! gridò il capitano, scaricando il suo fucile in mezzo
alla banda di coccodrilli.
Il marinaio, il chinese ed Hans afferrarono i remi e si misero ad
arrancare disperatamente, dirigendo la scialuppa verso la sponda
sinistra, mentre Cornelio ed il capitano, con frequenti fucilate,
tenevano lontani i sauriani, i quali scoraggiati, non parevano più
risoluti a continuare l’assalto.
In pochi istanti la scialuppa attraversò il fiume e si arenò sulla riva,
in mezzo ad un gigantesco mazzo di erbe acquatiche.
Stavano per sbarcare, quando verso il basso corso del fiume udirono
delle voci umane ed uno sbattere di remi.
— Chi s’avvicina? chiese il capitano.
— I pirati senza dubbio, disse Wan-Horn. Hanno udito i nostri spari e
accorrono per assalirci.
— Dopo i coccodrilli i pirati! esclamò Cornelio. Che brutto paese e
che brutta notte!
— Tacete, disse il capitano.
Si curvò verso l’acqua e tese gli orecchi.
— Sì, diss’egli, dopo alcuni istanti. Devono essere pirati che salgono
il fiume. Ho udito lo sbattere di molti remi.
— Che salgano colle piroghe?
— Forse le hanno sciolte per renderle più leggiere e private dei ponti
e delle tettoie. Nascondiamo la scialuppa e salviamoci nei boschi.
CAPO XVI.
La capanna aerea

Non vi era un momento da perdere. I pirati, attirati


da quei numerosi spari, si erano affrettati a salire
per cercare farli prigionieri prima che cadessero in
altre mani.
Forse credevano che fossero stati assaliti dagli
indigeni e accorrevano non già per difenderli, ma
per tema che i nuovi arrivati s’impadronissero di
quelle prede viventi e saccheggiassero la scialuppa
senza di loro.
I naufraghi, che udivano le voci avvicinarsi e che ormai
distinguevano perfettamente i colpi dei remi, tirarono la scialuppa a
terra e la coprirono con un ammasso di rami e di foglie, per non
perderla e venire privati dei viveri e delle coperte che non potevano
portare con loro. Per maggior precauzione si caricarono delle
munizioni, non volendo lasciarle nella scialuppa, la quale poteva
venire scoperta e saccheggiata quantunque fosse ormai bene
nascosta.
— A terra, disse il capitano.
Alla svolta del fiume era apparsa una piroga montata da parecchi
uomini e più oltre si vedeva la prua di un’altra. I naufraghi ne
sapevano abbastanza: balzarono in mezzo ai cespugli e si lanciarono
sotto la foresta, volgendo le spalle al corso d’acqua.
Quella boscaglia era fitta assai e tanto oscura che a malapena si
potevano distinguere i tronchi degli alberi, ma Cornelio, che aveva
già scorrazzato per lunghi anni le foreste di Timor, si era messo alla
testa del drappello e lo guidava dirigendosi verso l’ovest.
Gli alberi si succedevano agli alberi: alcuni alti, lisci, enormi, che
spiegavano i loro rami a sessanta o settanta metri d’altezza, altri più
bassi, nodosi, curvati innanzi od indietro ed altri ancora sottili,
coperti di foglie gigantesche che misuravano non meno di sei metri
di lunghezza su uno di larghezza. Liane interminabili, nepentes o
piante arrampicanti, s’intrecciavano dovunque, correndo da un
tronco all’altro, formando delle reti immense, capaci di accalappiare
perfino gli elefanti, mentre da terra sorgevano radici mostruose le
quali serpeggiavano qua e là, rendendo difficile il passaggio,
specialmente con quell’oscurità. Cornelio procedeva con precauzione
per non urtare contro quei centomila ostacoli e sopratutto per non
mettere il piede su qualcuno di quei serpenti pitoni, lunghi sette e
perfino otto metri, dotati d’una forza così prodigiosa da stritolare un
bue fra le loro spire e che sono così numerosi nelle foreste delle isole
Malesi e anche in quelle della Nuova Guinea.
Camminavano da un’ora, sempre allontanandosi dal fiume per far
perdere le loro traccie ai pirati, quando si trovarono improvvisamente
dinanzi ad una piccola pianura, circondata da altre foreste.
Con sua grande sorpresa, Cornelio vide elevarsi, quasi in mezzo a
quel terreno scoperto, una massa nera, enorme, che pareva sospesa
in aria, ad un’altezza di quattordici o sedici metri.
— Zio! esclamò.
— Cos’hai scoperto? chiese Wan-Stael, uscendo dalla foresta.
— Guarda!
— È un’abitazione di papù, disse il capitano. Brutta sorpresa, se è
abitata.
— Un’abitazione!...
— Sì, Cornelio. I papù, per non farsi sorprendere dai nemici o dalle
fiere, fabbricano le loro capanne su dei pali giganteschi.
— Ma quella è immensa.
— Abitano parecchie famiglie in quelle case aeree. Sono costruzioni
che meritano di essere vedute.
— Che sia abitata? chiese Wan-Horn.
— Lo sapremo subito. Alla sera gli inquilini ritirano i bambù intagliati
che servono a loro di scale, e se a quella capanna mancano sarà
segno che è abitata.
— Se la fosse, i papù avrebbero udito i nostri spari e non
dormirebbero, osservò Hans.
— Hai ragione, disse il capitano. Quale fortuna se fosse vuota!...
— La occuperemo? chiese Cornelio.
— Senza perdere tempo. Di lassù potremo difenderci contro i pirati,
se vengono ad assalirci.
— E non cadrà, quella baracca? Ho poca fiducia, zio mio, di queste
costruzioni.
— Sono solidissime, Cornelio; appoggiano su grosse canne di bambù
e tu sai come sono robuste, malgrado la loro leggerezza. Seguitemi,
amici, ma senza far rumore.
Tenendosi nascosti fra i cespugli e le piante arrampicanti che
ingombravano la piccola pianura, i naufraghi s’avvicinarono a quella
bizzarra costruzione che aveva delle dimensioni enormi e si
arrestarono dinanzi ai primi pali.
Quella casa aerea, situata a sedici metri dal suolo, quantunque
costruita da selvaggi che nulla hanno appreso dagli ingegneri
europei, era veramente meravigliosa e faceva molto onore ai suoi
costruttori.
Nulla può darvi un’idea dell’arditezza di quelle case, le quali inoltre
sono d’una solidità a tutta prova, tale anzi da poter sfidare
impunemente i venti più impetuosi.
Per costruirle, i papuasi piantano dapprima, e molto profondamente,
dei grossi e lunghi bambù leggieri ma resistenti, incorruttibili poichè
mai marciscono, incrociandoli e legandoli con fibre di rotang o con
liane, ma in modo da sorreggersi gli uni con gli altri.
A dieci metri dal suolo costruiscono un primo pavimento, una specie
di terrazzo, con bambù più leggieri e con nervature di foglie
intrecciate, il quale riunisce tutte le pertiche consolidandole
maggiormente.
Più sopra, a quattordici metri d’altezza, ne costruiscono un secondo
assai più vasto, più sporgente del primo e anche più solido, dovendo
reggere gli abitanti della casa.
Sopra questo elevano l’abitazione, colle pareti di bambù e di stuoie
ed un tetto a due pioventi, coperto da larghe foglie, le quali bastano
per impedire i filtramenti delle scarse pioggie che cadono in quelle
regioni.
Per evitare che i nemici possano sorprenderli nel sonno si servono di
due o tre pertiche per salire, fornite di tacche ad una certa distanza.
Appoggiano sulla seconda piattaforma, ma non sono fisse, poichè
alla sera si ritirano, e terminano su di un piccolo pianerottolo situato
a sei metri da terra e sul quale si giunge servendosi di altre pertiche
pure mobili.
Quando le famiglie papù si trovano nella loro capanna aerea,
possono sfidare le fiere e anche i nemici, poichè senza quelle
pertiche non si può salire lassù. Se alcuni volessero tentare
l’ascensione, sarebbero costretti ad appoggiare nuove pertiche, ma il
solo urto basterebbe per far oscillare l’intera costruzione e mettere in
allarme gli abitanti.
Il capitano, che aveva veduto ben altre di quelle capanne, girò
attorno ai bambù di sostegno e trovò due pertiche che mettevano
sul pianerottolo, e più sopra ne vide altre due che s’appoggiavano
alla piattaforma superiore.
— Quest’abitazione è stata abbandonata, disse.
— Che i proprietari siano stati uccisi? chiese Cornelio.
— Può essere; i papù della costa e quelli dell’interno si odiano
ferocemente e si distruggono a vicenda con guerre sanguinosissime;
però aggiungerò che i papù emigrano sovente.
— Approfittiamo dell’assenza dei proprietari e occupiamo questa
bizzarra abitazione.
Stava per issarsi sulle pertiche, quando il capitano lo arrestò.
— Adagio, diss’egli. Gli abitanti possono essere discesi, ma ve ne
possono essere altri lassù e cacciarti in petto una freccia avvelenata.
Prima voglio assicurarmi se questa casa è proprio disabitata.
Afferrò due bambù e li scrollò furiosamente. L’intera costruzione
oscillò dalla base alla cima con un forte rumore, senza però cedere,
tanto era solida.
— Se vi sono degli abitanti che dormono, si sveglieranno, disse.
Attesero cogli occhi fissi sulla capanna aerea, ma nessun essere
umano apparve sulla grande piattaforma. Solamente alcuni uccelli,
che dormivano sul tetto, volarono via emettendo strida di spavento.
— Non vi è nessuno, disse Wan-Horn. Possiamo salire.
Cornelio si mise ad arrampicarsi su una pertica, appoggiando i piedi
e le mani sulle tacche, mentre il capitano si inerpicava sull’altra e
giunsero sul pianerottolo.
Diedero all’edificio una seconda scrollata, ma non udendo alcun
rumore, nè vedendo comparire alcuna persona, salirono più su,
giungendo felicemente sulla grande piattaforma sostenente la
capanna.
Colà furono costretti ad arrestarsi, poichè quel pavimento era
tutt’altro che praticabile pei loro piedi. Infatti i papù, che sono agili
come le scimmie, non si prendono grandi cure pei pavimenti delle
loro abitazioni, e lasciano i bambù scoperti.
Essendo questi disposti ad intervalli di venti ed anche di trenta
centimetri, lasciano fra loro delle aperture che possono causare delle
cadute mortali, per chi non è abituato ad una ginnastica indiavolata
e soffre i capogiri. Gli abitanti non ne coprono che una parte, quelli
che si trovano nell’interno della casa e non sempre.
La terrazza esterna è priva di stuoie, quindi per attraversarla bisogna
avanzarsi a salti, e con piede molto sicuro, se si vuole evitare il
pericolo di cadere sulla piattaforma inferiore.
— Diamine! esclamò Cornelio. Questo pavimento è un vero
trabocchetto, zio mio.
— Non è molto comodo per noi, ma i papù se ne accontentano,
Cornelio.
— Ma è pericoloso pei ragazzi.
— Sono agili come gli scoiattoli e non si trovano imbarazzati. Avanti,
Cornelio.
— Non voglio correre il pericolo di mettere i piedi nel vuoto e di
capitombolare fino a terra, zio mio, cosa facile con questa oscurità.
Preferisco avanzarmi a carponi.
— È più sicuro, disse il capitano ridendo.
Tenendosi stretti ai bambù attraversarono la piattaforma ed
entrarono nella casa, il cui pavimento era coperto da grosse e solide
stuoie.
Quell’abitazione era vastissima, in forma d’un quadrilatero, con un
tetto ampio e assai sporgente, per coprire l’intera piattaforma. Era
diviso in quattro stanze lunghe otto o dieci metri, larghe altrettanto e
provviste tutte di porte, le quali mettevano sulla galleria esterna.
Il capitano accese l’esca, diede fuoco ad un pezzo di carta che aveva
trovato in una tasca della giubba e spinse lo sguardo nelle stanze,
ma non vide alcun abitante, nè alcun oggetto: erano tutte disabitate
e perfettamente vuote.
— Meglio per noi, disse. Passeremo qui il resto della notte e
dormiremo tranquillamente.
— Ritireremo le scale, disse Cornelio.
— L’ho già detto ad Horn.
Intanto Hans e il Chinese erano giunti sulla piattaforma ed erano
entrati nell’abitazione, ed il vecchio marinaio saliva ritirando le
pertiche per impedire ai pirati di raggiungerli.
— Finalmente possediamo una casa! esclamò Hans.
— Una vera fortezza, soggiunse Cornelio. Sfido i pirati a farci
sloggiare ed a trovarci.
— Se non ci hanno già scoperti, disse il marinaio entrando. Temo che
quelle canaglie siano più furbe di noi.
— Hai veduto qualche cosa di sospetto? chiese il capitano, con
inquietudine.
— Posso essermi ingannato, signor Wan-Stael, ma mentre ritiravo le
pertiche, mi parve di aver udito un leggiero fischio dalla parte della
foresta.
— Che abbiano scoperte le nostre traccie?
— Non so cosa dire, capitano.
— Ma con questa oscurità? disse Cornelio.
— I selvaggi hanno degli occhi migliori dei nostri, rispose il vecchio
marinaio. Talvolta danno dei punti agli animali notturni.
— Ma cosa sperano di guadagnare prendendoci?
— I nostri fucili, Cornelio, disse il capitano. Questo accanimento non
può spiegarsi diversamente.
— Apprezzano molto le armi da fuoco?
— E con ragione, non possedendo che delle cerbottane e degli archi.
Muniti di armi da fuoco, quei pirati possono diventare veramente
invincibili contro i loro compatriotti della costa.
— Ma se vorranno salire, avranno molto da fare.
— Purchè non ci taglino le pertiche di sostegno e ci facciano
capitombolare assieme alla casa, disse il marinaio. Hanno dei
parangs, e quelle pesanti sciabole tagliano meglio delle scuri.
— Che brutta caduta!
— Mortale, signor Cornelio.
— Usciamo, disse il capitano. Non bisogna lasciarli avvicinare.
Lasciarono la casa e si curvarono sui bambù della piattaforma
esterna, i quali essendo così larghi e permettevano di sorvegliare
tutti i dintorni della costruzione.
Non si udiva alcun rumore dalla parte della foresta: solamente la
brezza notturna sibilava debolmente fra i pali di sostegno, su diversi
toni.
Essendo sorta la luna si poteva distinguere un uomo ad una notevole
distanza, ma nessuno appariva su quella piccola pianura.
— Non odo nulla di sospetto, disse Cornelio.
— Ed io non vedo alcun pirata, disse Hans.
— Ma la pianura è coperta di cespugli e di piante arrampicanti assai
fitte, e quei bricconi possono avanzarsi strisciando, osservò Horn.
In quell’istante, quasi a conferma delle sue parole, una leggiera
striscia oscura fendette l’aria e venne a piantarsi sulla parete esterna
della capanna, a mezzo metro dalla testa del Chinese.
— Oh! esclamò il capitano.
Si rizzò rapidamente e la staccò.
— Una freccia, disse, prendendola con precauzione. È stata lanciata
da una cerbottana, non m’inganno.
Quella freccia era lunga venti centimetri; era un leggiero cannello di
bambù spinoso, aguzzato da una parte e fornito dall’altra d’un
piccolo fiocco di cotone e da un tappo di midolla vegetale.
— È avvelenata? chiese Cornelio.
— Certo, e vi ordino di ritirarvi nella capanna, perchè a chi tocca una
ferita è uomo morto. L’upas è un veleno che non perdona.
— Che l’abbiano lanciata i pirati?
— Senza dubbio, Cornelio; affrettiamoci a metterci al sicuro.
Abbandonarono la piattaforma e si ritirarono nella capanna nel
medesimo istante che una seconda freccia, partita da un cespuglio,
sibilava attraverso ai bambù, piantandosi sul tetto.
CAPO XVII.
Fra le freccie ed il fuoco

I papù in generale sono male armati e non


possono resistere ad un attacco degli uomini
bianchi muniti di buoni fucili; ma se i loro archi
sono di poca efficacia, le loro mazze, ruvidi bastoni
malamente lavorati, e le loro lancie poco meno che
inutili avendo per lo più le punte di osso,
posseggono però un’arma che produce ferite
mortali e che si presta molto nelle guerre
d’imboscate.
Non è certo di loro invenzione avendola
probabilmente appresa dagli isolani malesi e
specialmente bornesi, ma se ne servono con abilità straordinaria: è
la cerbottana o, come la chiamano i malesi, la sumpitan.
È un tubo di bambù lungo generalmente un metro e mezzo, di legno
duro, trapanato con un ferro appuntato, ma con molta precisione,
dovendo il foro interno essere rigorosamente eguale.
In questo tubo introducono un cannello di bambù od un nervo di
foglia munito superiormente d’una spina lunga ed assai acuta, e
inferiormente d’un tappo a cono di midolla vegetale, che corrisponde
al calibro dell’arma.
Soffiando entro la cerbottana, la freccia, spinta dall’aria, esce e
s’innalza per quaranta ed anche cinquanta metri, colpendo l’uccello,
o il nemico imboscato, con una precisione straordinaria.
L’uomo, o l’animale, o il volatile toccato, non ha scampo e morranno
fra pochi minuti, perchè le punte della freccia sono tinte nel succo
dell’upas, uno degli alberi più venefici che esistono.
Appena ricevuta la ferita, l’uomo prova tosto un tremito convulso, il
polso si accelera, poi prova una debolezza estrema, un’ansietà
angosciosa, respirazione difficile, spasimi, vomiti, espulsioni fecali,
convulsioni tetaniche e quindi spira dopo dieci o quindici minuti.
Sembra che quel veleno agisca sul sistema circolatorio e sul sistema
nervoso.
Altre volte invece quelle freccie sono tinte nel succo del cetting
(strichnos tientè), pianta arrampicante più velenosa ancora dell’upas,
poichè la morte è più rapida, quasi fulminante.
Come si vede, non era il caso di rimanere all’aperto per difendere
meglio i dintorni della capanna aerea. Quelle due freccie, salite
lassù, e che il capitano aveva avuto tempo di vedere, dicevano
abbastanza di quali mezzi disponevano i pirati per tenerli lontani.
I naufraghi però, anche tenendosi dentro la capanna, potevano
difendersi e mandare le loro palle a destinazione, essendovi molte
aperture fra le pareti di graticcio dell’abitazione e parecchie porte.
Si dispersero per la casa per sorvegliare i dintorni da tutte le parti, e
si tennero pronti a rispondere alle provocazioni di quegli accaniti
assalitori.
Non attesero molto, poichè pochi minuti dopo scorsero dei corpi neri
strisciare fra i cespugli e le piante arrampicanti, tentando
d’avvicinarsi alle palizzate di sostegno.
Cornelio mirò il primo e fece fuoco. L’uomo colpito dall’infallibile palla
del bravo bersagliere, girò due volte su sè stesso, stramazzò al suolo
senza mandare un grido.
Quel colpo maestro sgomentò gli assalitori, poichè si videro tornare
rapidamente indietro e nascondersi fra i fitti alberi della foresta.
— Ecco uno che non tornerà più sul mare, disse Wan-Horn. Il
confetto è stato un po’ amaro per quel povero diavolo, ma meritato.
Ah! furfanti, ne avrete ben altri, prima di prenderci le armi!
— Sono pronto a ricominciare, disse Cornelio. Un altro che si mostri
e lo stendo a terra.
— In guardia! gridò il capitano.
Sette od otto freccie s’alzarono sibilando, ma erano partite troppo
lontane e due sole si piantarono nei bambù della piattaforma
esterna.
— Grandina! esclamò Cornelio.
— Ed è grandine avvelenata, aggiunse Wan-Horn. Fortunatamente
siamo fuori di pericolo, almeno per ora.
— Ma più tardi? disse il capitano, che pareva fosse diventato
inquieto. Se quei briganti prolungano l’assedio, cosa accadrà di noi?
— Non abbiamo fretta, zio, disse Cornelio. Si sta molto bene in
questa gabbia d’uccelli.
— Ma i viveri? Chi di noi possiede dell’acqua?
— È vero, zio. Io non ho che due biscotti e nemmeno una goccia
d’acqua.
— Che vogliano proprio assediarci? chiese Wan-Horn.
— Ne sono certo, vecchio mio. Essi calcolano di farci capitolare per
fame.
— No, zio, disse Hans. Non aspetteranno tanto, poichè li vedo a
ritornare: guarda!
Tutti si affacciarono alle porte e videro infatti i pirati avanzarsi
attraverso alla pianura. Strisciavano fra i cespugli e le piante
arrampicanti come i serpenti, cercando di non farsi scorgere.
— Che vengano a tagliare i pali di sostegno? brontolò Wan-Horn. A
voi, signor Cornelio.
Il giovanotto che aveva ricaricato il fucile, mandò una palla in mezzo
ad un cespuglio, le cui cime si movevano, ma nessun grido seguì lo
sparo.
— Mancato o ucciso sul colpo? disse il marinaio.
— Vedo i rami agitarsi ancora, disse Cornelio. Quei furfanti non
mostrano un pezzetto dei loro corpi, tanto sono ben nascosti.
Il capitano ed Hans fecero fuoco mirando i cespugli che si
muovevano, ma i pirati ormai non si scorgevano più e non risposero.
— Che si siano nascosti sotto terra? chiese il marinaio. Come va
questa faccenda?
Ad un tratto quindici o venti uomini balzarono dai cespugli e si
scagliarono verso l’abitazione, menando furiosi colpi di parangs
contro i pali di sostegno. In un momento sette od otto, troncati da
quelle pesanti sciabole, caddero a terra.
— Fuoco! gridò il capitano.
Tre colpi di fucile echeggiarono: due pirati caddero fulminati, un
terzo fuggì urlando ed andò a cadere in mezzo un cespuglio poco
discosto, e gli altri ritornarono precipitosamente nel bosco, salutati
da altre due fucilate.
— Hanno del coraggio, quelle canaglie! esclamò Wan-Horn.
Speriamo però che ne abbiano abbastanza delle nostre palle per ora.
Se continuavano a lavorare di sciabole, facevan capitombolare la
nostra gabbia.
— Non c’è pericolo, marinaio, disse il capitano. Vi sono almeno
duecento pali da tagliare, e prima che li recidano tutti li
distruggeremo.
— Credete che non ritentino l’attacco?
— Dopo questa seconda lezione spero che non oseranno avvicinarsi
ancora. Corichiamoci sulla piattaforma e teniamci pronti a mandare
un’altra grandinata di palle se tornano a mostrarsi.
Si sdraiarono dinanzi alle porte tenendo a fianco i fucili e attesero.
I pirati non abbandonavano la foresta che li proteggeva, ma non si
erano allontanati, poichè di tratto in tratto si udivano le loro voci e di
quando in quando qualche freccia saliva in aria, ma senza giungere
fino alla casa aerea.
Senza dubbio ne avevano avuto abbastanza delle palle degli
assediati e si erano accampati fra i tronchi d’albero per impedire ogni
tentativo di fuga. Probabilmente contavano di costringerli alla resa
colla fame, piano più sicuro e di esito certo, poichè i naufraghi non
potevano durare a lungo senza un sorso d’acqua.
La notte trascorse senza che i pirati rinnovassero il tentativo e senza
che gli assediati riaprissero il fuoco, volendo economizzare le
munizioni, quantunque avessero un migliaio di colpi da sparare.
Quando il sole apparve, illuminando le foreste circostanti, la
situazione non era cambiata. I pirati si udivano sempre a
chiacchierare, ma si erano affrettati a porsi in salvo dietro ai grossi
tronchi degli alberi.
— La va male, disse Wan-Horn. Se questo assedio continua, non so
come potremo resistere senza un sorso d’acqua.
— Se ci fosse qualche stagno in questa pianura, proverei a
discendere, disse Cornelio. Comincio ad essere annoiato di questa
prigionia, Horn.
— Ed è appena cominciata!... Avrete del tempo per annoiarvi di più,
signor Cornelio. I pirati non se ne vanno.
— Se provassimo a sloggiarli?
— In qual modo?
— Scendendo nella pianura e attaccandoli.
— Ci crivelleranno di freccie prima di toccare terra e voi sapete che
sono avvelenate.
— Ma se questo assedio si prolunga?
— Speriamo che si stanchino, signor Cornelio.
— Ma la sete si avanza, Horn.
— Resisteremo fin che potremo.
— Ah! se potessi scorgerli!...
— I furbi si tengono nascosti.
— Vediamo se possiamo costringerli a mostrarsi, vecchio Horn. Vedo
i rami di quel cespuglio a muoversi; forse là vi è una sentinella.
Armò il fucile e fece fuoco, ma i pirati risposero con una volata di
freccie, senza però abbandonare la foresta protettrice. Alcune
giunsero fino sulla piattaforma, ma le altre caddero a mezza via.
— Non si muovono, Wan-Horn, disse il giovinotto con stizza.
— Lo vedo, signor Cornelio. Sanno oramai che siamo abili tiratori e ci
tengono alla loro pelle; invece di sprecare le nostre palle, facciamo
colazione.
— Sarà molto magra, Horn.
— Ho tre biscotti.
— Ed io due.
— E voi, capitano?
— La mia pipa.
— E noi abbiamo le tasche vuote, dissero Hans ed il chinese.
— Non c’è pericolo di fare una indigestione, disse il marinaio, il quale
però non perdeva il suo buon umore.
Si divisero fraternamente i cinque biscotti, che in pochi bocconi
fecero sparire, poi si stesero sui graticci e s’addormentarono sotto la
guardia del marinaio, avendo passata l’intera notte in continui
allarmi.
La giornata lentamente trascorse senza che i pirati tentassero un
nuovo assalto; non avevano però abbandonato il bosco, poichè di
quando in quando lanciavano qualche freccia. Quando calarono le
tenebre i poveri assediati erano già alle prese colla fame e sopratutto
colla sete. Dal mattino non avevano messo sotto i denti che quei
pochi biscotti e dalla sera precedente non avevano ingoiato un sorso
d’acqua. Nessuno però si era lamentato, e perfino Hans che era il più
giovine di tutti aveva resistito eroicamente, quantunque avesse la
gola arida e la lingua ingrossata. La brezza della notte recò qualche
sollievo ai poveri assetati, ma era ben poca cosa, e se quell’assedio
non cessava non avrebbero potuto sopportare un digiuno di altre
ventiquattro ore.
— Bisogna tentare qualche cosa, disse il capitano con voce risoluta.
Hans non può sopportare simili privazioni.
— Non mi lamento, zio, rispose il giovane. Se resistete voi, terrò
duro anch’io.
— No, mio povero ragazzo, tu non ancora sei un uomo. Questa notte
andrò in cerca d’acqua.
— Ti uccideranno, zio.
— Cercherò di scendere senza farmi vedere.
— Verrò anch’io, zio, disse Cornelio.
— Ed io? disse Horn. Lasciate che tenti io la discesa, capitano; ho
sessant’anni e uccideranno un uomo che ha vissuto abbastanza.
— No, mio bravo Horn, rimarrai qui a vegliare sui nipoti miei. Non sei
più agile come un tempo e la discesa non è facile.
— I muscoli sono ancora solidi, capitano, e scenderò meglio d’un
mozzo. Se vi uccidono, chi ricondurrà in patria i vostri nipoti?
— Tu sei un marinaio che può condurre una scialuppa anche più
lontano dell’isola di Timor. D’altronde non mi hanno ancora ucciso
quei birbanti, e dubito che vi riescano.
— Lascia che vada io, zio, disse Cornelio. Corro come un cervo, e se i
pirati m’inseguiranno, li farò scoppiare prima che mi raggiungano.
— No, mio valoroso nipote, non voglio... oh!
Wan-Stael si era bruscamente voltato verso le boscaglie occupate dai
pirati ed era divenuto pallido.
— Cos’hai veduto, zio? chiesero Hans e Cornelio, montando
precipitosamente i fucili.
— Ho veduto un punto luminoso, una fiammella solcare le tenebre.
— Dove? chiesero tutti.
— Verso il bosco.
— Che i pirati cerchino d’incendiarci la casa? chiese Wan-Horn.
— Lo temo, disse il capitano. Vedo un fuoco brillare nella foresta.
— Ed io i pirati che strisciano fra le piante, disse Cornelio.
— Preparate le armi; se riescono a incendiare i bambù, questa
abitazione cadrà come un fastello di paglia. Li vedi, Cornelio?
— Si sono nascosti dietro a quel macchione. Ah!..
Una fiammella si era alzata dalla macchia ed era caduta sulla parte
anteriore della piattaforma, lasciandosi dietro parecchie scintille.
Cornelio, a rischio di cadere nel vuoto e di ricevere una freccia nel
petto, balzò attraverso ai bambù e la gettò via prima che
comunicasse il fuoco ai legnami dell’edificio.
— Sono freccie, gridò egli.
— Freccie! esclamò il capitano.
— Sì, zio, ma sulla punta portano un fiocco di cotone acceso.
— I birbanti! esclamò Horn. Cercano di appiccare il fuoco alla
capanna senza mostrarsi.
Un’altra freccia infiammata s’alzò dalla macchia e s’infisse nella
parete della casa, minacciando d’incendiare i tralicci e le stuoie di
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and


personal growth!

textbookfull.com

You might also like