0% found this document useful (0 votes)
25 views66 pages

Learn Microservices with Spring Boot: A Practical Approach to RESTful Services using RabbitMQ, Eureka, Ribbon, Zuul and Cucumber 1st Edition Moises Macero (Auth.) - The full ebook with all chapters is available for download

The document promotes various ebooks available for download at textbookfull.com, focusing on topics related to microservices and Spring Boot. It highlights several titles, including 'Learn Microservices with Spring Boot' by Moises Macero and 'Practical Microservices Architectural Patterns' by Christudas, among others. The ebooks cover practical approaches to RESTful services, event-driven architecture, and full-stack development with modern frameworks.

Uploaded by

haffardeckie
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
0% found this document useful (0 votes)
25 views66 pages

Learn Microservices with Spring Boot: A Practical Approach to RESTful Services using RabbitMQ, Eureka, Ribbon, Zuul and Cucumber 1st Edition Moises Macero (Auth.) - The full ebook with all chapters is available for download

The document promotes various ebooks available for download at textbookfull.com, focusing on topics related to microservices and Spring Boot. It highlights several titles, including 'Learn Microservices with Spring Boot' by Moises Macero and 'Practical Microservices Architectural Patterns' by Christudas, among others. The ebooks cover practical approaches to RESTful services, event-driven architecture, and full-stack development with modern frameworks.

Uploaded by

haffardeckie
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/ 66

Explore the full ebook collection and download it now at textbookfull.

com

Learn Microservices with Spring Boot: A Practical


Approach to RESTful Services using RabbitMQ,
Eureka, Ribbon, Zuul and Cucumber 1st Edition
Moises Macero (Auth.)
https://textbookfull.com/product/learn-microservices-with-
spring-boot-a-practical-approach-to-restful-services-using-
rabbitmq-eureka-ribbon-zuul-and-cucumber-1st-edition-moises-
macero-auth/

OR CLICK HERE

DOWLOAD EBOOK

Browse and Get More Ebook Downloads Instantly at https://textbookfull.com


Click here to visit textbookfull.com and download textbook now
Your digital treasures (PDF, ePub, MOBI) await
Download instantly and pick your perfect format...

Read anywhere, anytime, on any device!

Learn Microservices with Spring Boot: A Practical Approach


to RESTful Services Using an Event-Driven Architecture,
Cloud-Native Patterns, and Containerization 2nd Edition
Moisés Macero García
https://textbookfull.com/product/learn-microservices-with-spring-boot-
a-practical-approach-to-restful-services-using-an-event-driven-
architecture-cloud-native-patterns-and-containerization-2nd-edition-
moises-macero-garcia/
textbookfull.com

Biota Grow 2C gather 2C cook Loucas

https://textbookfull.com/product/biota-grow-2c-gather-2c-cook-loucas/

textbookfull.com

Learn Microservices with Spring Boot Second Edition Moisés


Macero García Macero García Moisés

https://textbookfull.com/product/learn-microservices-with-spring-boot-
second-edition-moises-macero-garcia-macero-garcia-moises/

textbookfull.com

Practical Microservices Architectural Patterns: Event-


Based Java Microservices with Spring Boot and Spring Cloud
Christudas
https://textbookfull.com/product/practical-microservices-
architectural-patterns-event-based-java-microservices-with-spring-
boot-and-spring-cloud-christudas/
textbookfull.com
Practical Microservices Architectural Patterns - Event-
Based Java Microservices with Spring Boot and Spring Cloud
1st Edition Binildas Christudas
https://textbookfull.com/product/practical-microservices-
architectural-patterns-event-based-java-microservices-with-spring-
boot-and-spring-cloud-1st-edition-binildas-christudas/
textbookfull.com

Spring Boot 2 0 Projects Build production grade reactive


applications and microservices with Spring Boot English
Edition Mohamed Shazin Sadakath
https://textbookfull.com/product/spring-boot-2-0-projects-build-
production-grade-reactive-applications-and-microservices-with-spring-
boot-english-edition-mohamed-shazin-sadakath/
textbookfull.com

RESTful Java Web Services A pragmatic guide to designing


and building RESTful APIs using Java 3rd Edition
Balachandar
https://textbookfull.com/product/restful-java-web-services-a-
pragmatic-guide-to-designing-and-building-restful-apis-using-java-3rd-
edition-balachandar/
textbookfull.com

RESTful Web API Design with Node js 10 Learn to create


robust RESTful web services with Node js MongoDB and
Express js 3rd Edition English Edition Valentin Bojinov
https://textbookfull.com/product/restful-web-api-design-with-node-
js-10-learn-to-create-robust-restful-web-services-with-node-js-
mongodb-and-express-js-3rd-edition-english-edition-valentin-bojinov/
textbookfull.com

Full stack development with JHipster build full stack


applications and microservices with Spring Boot and modern
JavaScript frameworks Second Edition Sendil Kumar N.
https://textbookfull.com/product/full-stack-development-with-jhipster-
build-full-stack-applications-and-microservices-with-spring-boot-and-
modern-javascript-frameworks-second-edition-sendil-kumar-n/
textbookfull.com
Learn
Microservices
with Spring Boot
A Practical Approach to RESTful
Services using RabbitMQ, Eureka,
Ribbon, Zuul and Cucumber

Moises Macero
Learn Microservices
with Spring Boot
A Practical Approach to RESTful
Services using RabbitMQ,
Eureka, Ribbon, Zuul and
Cucumber

Moises Macero
Learn Microservices with Spring Boot: A Practical Approach to
RESTful Services using RabbitMQ, Eureka, Ribbon, Zuul and Cucumber
Moises Macero
New York, USA

ISBN-13 (pbk): 978-1-4842-3164-7 ISBN-13 (electronic): 978-1-4842-3165-4


https://doi.org/10.1007/978-1-4842-3165-4
Library of Congress Control Number: 2017962334

Copyright © 2017 by Moises Macero


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
publication, 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.
Cover image by Freepik (www.freepik.com)
Managing Director: Welmoed Spahr
Editorial Director: Todd Green
Acquisitions Editor: Steve Anglin
Development Editor: Matthew Moodie
Technical Reviewer: Manuel Jordan Elera
Coordinating Editor: Mark Powers
Copy Editor: Kezia Endsley
Distributed to the book trade worldwide by Springer Science+Business Media New York,
233 Spring Street, 6th Floor, New York, NY 10013. 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], or visit
http://www.apress.com/rights-permissions.
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/
9781484231647. For more detailed information, please visit http://www.apress.com/
source-code.
Printed on acid-free paper
Table of Contents
About the Author���������������������������������������������������������������������������������ix
About the Technical Reviewer�������������������������������������������������������������xi

Chapter 1: Introduction������������������������������������������������������������������������1
Setting the Scene��������������������������������������������������������������������������������������������������1
Who Are You?��������������������������������������������������������������������������������������������������������2
How Is This Book Different from Other Books and Guides?����������������������������������3
Reasoning Behind the Techniques������������������������������������������������������������������3
Learning: An Incremental Process�������������������������������������������������������������������4
Is This a Guide or a Book?�������������������������������������������������������������������������������4
Contents����������������������������������������������������������������������������������������������������������������5
From the Basics to Advanced Topics���������������������������������������������������������������5
Skeleton with Spring Boot, the Professional Way��������������������������������������������5
Test-Driven Development��������������������������������������������������������������������������������6
Connecting Microservices�������������������������������������������������������������������������������6
Event-Driven System���������������������������������������������������������������������������������������6
End-to-End Testing������������������������������������������������������������������������������������������7
Summary��������������������������������������������������������������������������������������������������������������7

iii
Table of Contents

Chapter 2: The Basic Spring Boot Application��������������������������������������9


Business Requirements����������������������������������������������������������������������������������������9
The Skeleton App������������������������������������������������������������������������������������������������10
Skinny vs. Real-Life Apps������������������������������������������������������������������������������10
Creating the Skeleton������������������������������������������������������������������������������������11
Warming Up: Some TDD in Action�����������������������������������������������������������������������13
Summary������������������������������������������������������������������������������������������������������������21

Chapter 3: A Real Three-­Tier Spring Boot Application������������������������23


Introduction���������������������������������������������������������������������������������������������������������23
Completing the Basics����������������������������������������������������������������������������������������26
Designing the Domain�����������������������������������������������������������������������������������������33
The Business Logic Layer�����������������������������������������������������������������������������������38
The Presentation Layer (REST API)����������������������������������������������������������������������41
The Multiplication Controller�������������������������������������������������������������������������43
The Results Controller�����������������������������������������������������������������������������������48
The Frontend (Web Client)�����������������������������������������������������������������������������������53
Playing with the Application (Part I)��������������������������������������������������������������������58
New Requirements for Data Persistence������������������������������������������������������������59
Refactoring the Code������������������������������������������������������������������������������������������63
The Data Layer����������������������������������������������������������������������������������������������������68
The Data Model���������������������������������������������������������������������������������������������71
The Repositories��������������������������������������������������������������������������������������������77
Completing User Story 2: Going Through the Layers������������������������������������������87
Playing with the Application (Part II)�������������������������������������������������������������������94
Summary������������������������������������������������������������������������������������������������������������97

iv
Table of Contents

Chapter 4: Starting with Microservices����������������������������������������������99


The Small Monolith Approach�����������������������������������������������������������������������������99
Analyzing the Monolith��������������������������������������������������������������������������������103
Moving Forward�������������������������������������������������������������������������������������������105
Gamification Basics������������������������������������������������������������������������������������������106
Points, Badges, and Leaderboards��������������������������������������������������������������106
Applying It to the Example���������������������������������������������������������������������������107
Moving to a Microservices Architecture������������������������������������������������������������108
Separation of Concerns and Loose Coupling�����������������������������������������������108
Independent Changes����������������������������������������������������������������������������������109
Scalability����������������������������������������������������������������������������������������������������109
Connecting Microservices���������������������������������������������������������������������������������110
Event-Driven Architecture���������������������������������������������������������������������������������112
Related Techniques�������������������������������������������������������������������������������������113
Pros and Cons of Event-Driven Architecture�����������������������������������������������114
Further Reading�������������������������������������������������������������������������������������������117
Applying Event-Driven Architecture to the Application��������������������������������118
Going Event-Driven with RabbitMQ and Spring AMQP��������������������������������������119
Using RabbitMQ in Your System������������������������������������������������������������������120
Spring AMQP������������������������������������������������������������������������������������������������121
Sending Events from Multiplication������������������������������������������������������������������121
RabbitMQ Configuration������������������������������������������������������������������������������122
Modeling the Event��������������������������������������������������������������������������������������125
Sending the Event: Dispatcher Pattern��������������������������������������������������������128
Deeper Look at the New Gamification Microservice�����������������������������������134

v
Table of Contents

Receiving Events with RabbitMQ����������������������������������������������������������������������154


The Subscriber’s Side����������������������������������������������������������������������������������154
RabbitMQ Configuration������������������������������������������������������������������������������154
The Event Handler���������������������������������������������������������������������������������������157
Requesting Data Between Microservices���������������������������������������������������������160
Combining Reactive Patterns and REST������������������������������������������������������160
Keeping Domains Isolated���������������������������������������������������������������������������162
Implementing the REST Client���������������������������������������������������������������������165
Updating Gamification’s Business Logic�����������������������������������������������������170
Playing with the Microservices�������������������������������������������������������������������������173
Summary����������������������������������������������������������������������������������������������������������176

Chapter 5: The Microservices Journey Through Tools����������������������179


Introduction�������������������������������������������������������������������������������������������������������179
Extracting the UI and Connecting It to Gamification�����������������������������������������180
Moving the Static Content���������������������������������������������������������������������������182
Connecting UI with Gamification�����������������������������������������������������������������184
Changes to Existing Services����������������������������������������������������������������������187
A New, Better UI with (Almost) No Effort�����������������������������������������������������190
The Current Architecture�����������������������������������������������������������������������������������200
Service Discovery and Load Balancing�������������������������������������������������������������202
Service Discovery����������������������������������������������������������������������������������������202
Load Balancing��������������������������������������������������������������������������������������������205
Polyglot Systems, Eureka, and Ribbon��������������������������������������������������������207
Routing with an API Gateway����������������������������������������������������������������������������209
The API Gateway Pattern�����������������������������������������������������������������������������209
Zuul, Eureka, and Ribbon Working Together������������������������������������������������214

vi
Table of Contents

Hands-On Code�������������������������������������������������������������������������������������������������218
Implementing the API Gateway with Zuul����������������������������������������������������218
Playing with Service Discovery�������������������������������������������������������������������237
Are Our Microservices Ready to Scale?������������������������������������������������������241
Load Balancing with Ribbon������������������������������������������������������������������������244
Circuit Breakers and REST Clients��������������������������������������������������������������������254
Circuit Breakers with Hystrix�����������������������������������������������������������������������254
Hystrix and Zuul�������������������������������������������������������������������������������������������255
Hystrix from a REST Client���������������������������������������������������������������������������258
REST Consumers with Feign�����������������������������������������������������������������������261
Microservices Patterns and PaaS���������������������������������������������������������������������263
Summary����������������������������������������������������������������������������������������������������������264

Chapter 6: Testing the Distributed System���������������������������������������267


Introduction�������������������������������������������������������������������������������������������������������267
Setting the Scene����������������������������������������������������������������������������������������������269
How Cucumber Works���������������������������������������������������������������������������������������271
Hands-On Code�������������������������������������������������������������������������������������������������273
Creating an Empty Project and Choosing the Tools�������������������������������������274
Making the System Testable������������������������������������������������������������������������278
Writing the First Cucumber Test������������������������������������������������������������������287
Linking a Feature to Java Code�������������������������������������������������������������������291
The Supporting Classes�������������������������������������������������������������������������������302
Reusing Steps Across Features�������������������������������������������������������������������308
Running Tests and Checking Reports����������������������������������������������������������311
Summary����������������������������������������������������������������������������������������������������������314

vii
Table of Contents

Appendix A: Upgrading to Spring Boot 2.0���������������������������������������315


I ntroduction�������������������������������������������������������������������������������������������������������315
Upgrading the Dependencies����������������������������������������������������������������������������316
Fixing the Breaking Changes����������������������������������������������������������������������������319
The CrudRepository Interface Does Not Include findOne( )��������������������������319
Actuator Endpoints Have Been Moved��������������������������������������������������������320
Applying Optional Updates��������������������������������������������������������������������������������321
The WebMvcConfigurerAdapter Class Has Been Deprecated����������������������321
Working with Spring Boot 2.0���������������������������������������������������������������������������322

Afterword������������������������������������������������������������������������������������������323

Index�������������������������������������������������������������������������������������������������325

viii
About the Author
Moises Macero has been a software developer
since he was a kid. He has worked at big
companies and also at startups, where being
a full-stack developer was essential. During
his career, Moises has most often worked in
development, design, and architecture, for
small and large projects, and in both Agile and
waterfall environments. He likes working in
teams where he can not only coach others but
also learn from them.
Moises is also the author of the blog
thepracticaldeveloper.com, where he shares with others solutions for
technical challenges, guides and his view on ways of working in IT
companies. In his free time, he enjoys traveling and hiking.
You can follow Moisés on his twitter account @moises_macero.

ix
About the Technical Reviewer
Manuel Jordan Elera is an autodidactic
developer and researcher who enjoys learning
new technologies for his own experiments,
which focus on finding new ways to integrate
them.
Manuel won the 2010 Springy Award –
Community Champion and Spring Champion
2013. In his little free time, he reads the Bible
and composes music on his bass and guitar.
Manuel believes that constant education
and training is essential for all developers. You can reach him mostly
through his twitter account @dr_pompeii.

xi
CHAPTER 1

Introduction
S
 etting the Scene
Microservices are getting very popular these days. It’s not a surprise; this
software architecture style has a lot of advantages, like flexibility and ease
of scale. Mapping them into small teams in an organization also gives you
a lot of efficiency in development. However, going on the adventure of
microservices knowing only the benefits is a wrong call: you need to know
what you are facing and be prepared for that in advance. You can get a lot
of knowledge from many books and articles on the Internet but, when you
get hands-on code, the story changes.
This book covers some of the most important concepts of microservices
in a practical way, but not without explaining the concepts. First, we define
a use case: an application to build. Then we start with a small monolith,
based on some sound reasoning. Once we have the minimal application in
place, we evaluate if it’s worthy to move to microservices, and what would
be a good way to do so. How should we communicate these different pieces?
Then we can describe and introduce the event-driven architecture pattern
to reach loose coupling by informing other parts of the system about what
happened in your part of the process, instead of explicitly calling others to
action. Once you have the microservices in place, you see in practice how
the surrounding tools work: service discovery, routing, etc. We don’t cover all
of them at once but include them one by one, explaining the benefits of each
for the application. Also, we analyze what would be a good way to test the
distributed system, end-to-end.

© Moises Macero 2017 1


M. Macero, Learn Microservices with Spring Boot,
https://doi.org/10.1007/978-1-4842-3165-4_1
Chapter 1 Introduction

The advantage of going step-by-step, pausing when it’s needed to settle


down the concepts, is that you will understand which problem each tool is
trying to solve. That’s why the evolving example is an essential part of this
book. You can also grasp the concepts without coding one single line: most
of the source code is included so you can read it if you prefer.
The source code included in this book is available on the GitHub repository
https://github.com/microservices-practical. It’s divided into
different versions, which makes it easier for you to see how the application
evolves along the chapters. The book includes notes with the version that
is being covered in that section.

Who Are You?


Let’s first start with this: how interesting is this book going to be for you?
This book is practical, so let’s play this game. If you identify with any of
these statements, this book might be good for you.

• I would like to learn how to build microservices with


Spring Boot and how to use the related tools.

• Everybody is talking about microservices but I have no


clue what a microservice is yet: either I read theoretical
explanations or just hype-enforcing articles. I can’t
understand the advantages, even though I work in IT…

• I would like to learn how to design and develop Spring


Boot applications, but people are recommending
Don-­Quixote-­sized books,1 sometimes even several
of them. Is there any single source from which I can get
a quick, practical grip on microservices without reading
1,000 pages?

1
Don Quixote. Even though it is a long book, it is still a masterpiece.

2
Chapter 1 Introduction

• I got a new job, and they’re using a microservices


architecture. I’ve been working mainly in big,
monolithic projects, so I’d like to have some knowledge
and guidance to learn how everything works there.
• Every time I go to the cafeteria developers are talking
about microservices… I can’t socialize anymore with
my colleagues if I don’t get what they’re saying. Okay,
this is a joke; don’t read this book because of that,
especially if you’re not interested in programming.

Regarding the knowledge required to read this book, the following


topics should be familiar to you:

• Java (some code parts use Java 8 in this book)

• Spring (you don’t need strong experience but you should


know, at least, how dependency injection works)

• Maven (if you know Gradle, you’ll be fine as well)

 ow Is This Book Different from Other


H
Books and Guides?
Reasoning Behind the Techniques
Software developers and architects read many technical books and guides,
either because we’re interested in learning new technologies or just
because we need it for our work. We need to do that anyway since it’s a
constantly-changing world. We can find all kinds of books and guides out
there. Good ones are usually those from which you learn quickly, and ones
that teach you not only how to do stuff, but also why you should do it that
way. Using new techniques just because they’re new is the wrong way to
go about it; you need to understand the reasoning behind them so you use
them in the best way possible.

3
Chapter 1 Introduction

This book uses that philosophy: it navigates through the code and
design patterns, explaining the reasons to follow one way and not others.

Learning: An Incremental Process


If you look at the guides available on the Internet, you’ll notice quickly that
they are not real-life examples. Usually, when you apply those cases to
more complex scenarios, they don’t fit. Guides are too shallow to help you
building something real.
Books, on the other hand, are much better at that. There are plenty
of good books explaining concepts around an example; they are good
because applying theoretical concepts to code is not always easy if you
don’t see the code. The problem with some of these books is that they’re
not as practical as guides. You need to read them first to understand the
concepts, then code (or see) the example, which is frequently given as a
whole piece. It’s difficult to put into practice concepts when you see the
final version directly. This book stays on the practical side and starts with
code that evolves through refactoring, so the concepts are understood
step-by-step. We cover the problem before exposing the solutions.
Because of this incremental way of presenting concepts, this book also
allows you to code as you learn and to reflect on the challenges by yourself.

Is This a Guide or a Book?


The pages you have in front of you can’t be called a guide: it won’t take
you 15 or 30 minutes to finish them. But this is not the typical book either,
in which you go through concepts illustrated with some code fragments.
Instead, you start with a version of the code that is not yet optimal, and
you learn how to evolve it, after learning about the benefits you can extract
from that process.
That does not mean that you can’t just sit down and read it, but it’s better
if you code at the same time and play with the options and alternatives
presented. That’s the part of the book that makes it similar to a guide.

4
Chapter 1 Introduction

In any case, to keep it simple, from here onward we call this a book.

C
 ontents
From the Basics to Advanced Topics
This book focuses first on some basics about how to design and implement
a production-ready Spring Boot application using well-known architecture
patterns (Chapters 2 and 3). From there, it takes you through the journey
of tools and frameworks related to microservices with the introduction of
a second piece of functionality in a different Spring Boot app (Chapters 4
and 5). It also shows you how to support such a distributed system with
end-to-end integration tests (Chapter 6).
If you already know how to design Spring Boot applications, you can
go quickly through Chapters 2 and 3 and focus more on the second part
of the book. There, we cover topics like service discovery, routing, event-­
driven design, testing with Cucumber, etc. However, pay attention to the
strategy we set up in the first part—test-driven development, the focus on
the minimum viable product (MVP), and monolith-first.

Skeleton with Spring Boot, the Professional Way


First, the book guides you through the creation of an application using
Spring Boot. It’s mainly focused on the backend side, but you will create a
simple web page to demonstrate how to expose functionality as a REST API.
It’s important to point out that we don’t create “shortcut code” just
to see Spring Boot running: that’s not the objective of this book. We use
Spring Boot as a vehicle to teach concepts, but we could use any other
technique, and the ideas of this book would still be valid.
You learn how to design and implement the application following the
well-known three-tier, three-layer pattern. You do this supported by an
incremental example, with hands-on code. The result will be more than
enough for you to understand the professional way of writing applications.

5
Chapter 1 Introduction

Test-Driven Development
We use TDD to map the prerequisites presented to technical features (like
you should do in real life). TDD is a technique that sometimes can’t be
used at work (for many different reasons, none technical). But this book
tries to show it in a way that you can see the benefits from the beginning:
why it’s always a good idea to think about the test cases before writing your
code. AssertJ and Mockito will serve us to build useful tests efficiently.
The plan is the following: you’ll learn how to create the tests first, then
make them fail, and finally implement the logic to make them work.

Connecting Microservices
Once you have your first application ready, we introduce a second one
that will interact with the existing functionality. From that moment on,
you’ll have a microservices architecture. It doesn’t make any sense to try to
understand the advantages of microservices if you only have one of them.
The real-life scenarios are always distributed systems with functionality
split into different services. As usual, to keep it practical, you’ll see how
moving to microservices fits your needs.
The book covers not only the reasons to split the system but also what
the disadvantages are that come with that choice. And once you make the
decision, you’ll learn which tools you should use to make the system work
as a whole, and not as isolated services: service discovery, API gateway,
load balancing, and some other supporting tools.

Event-Driven System
An additional concept that does not always accompany microservices is an
event-driven architecture. This book uses it since it’s a pattern that fits very
well into a microservice architecture, and you’ll make your choice based
on good examples.

6
Chapter 1 Introduction

This asynchronous way of thinking introduces new ways of designing


code; you’ll look at it while coding your project, using RabbitMQ to
support it.

End-to-End Testing
If you want to code your project the professional way, you need to have a
production-ready mindset, so we’ll cover this functionality with tests. We
explain how to tackle the trickiest ones in a microservices architecture:
the end-to-end tests. We’ll use Cucumber since it’s a framework that
fits perfectly in many projects, filling the gap between the business
requirements and the test development. Even though nobody should need
reasons here to be convinced of why it is a good idea to have a proper test
base, we explain them to keep the testing skeptics happy.

Summary
This chapter introduced the main goals of this book: to teach you the
main aspects of a microservices architecture, by starting simple and then
growing your knowledge through the development of a sample project.
We also covered briefly the main contents of the book: from monolith-
first to microservices with Spring Boot, Test-Driven Development,
Event-Driven Systems and End-to-End testing with Cucumber.
Next chapter will start with the first step of our learning path: a basic
Spring Boot application.

7
CHAPTER 2

The Basic Spring


Boot Application
B
 usiness Requirements
We could start writing code directly but that, even being pragmatic, would
be far from being a real case. Software should have a goal: in this case, we
do it purely for the fact of learning but, anyway, we’ll give it a reason
(a fictional one). This requirements-oriented approach is used throughout
the book to make it more practical.
We want to write an application to encourage users to train their math
skills every day. To begin with, we will have two-digit multiplications
presented to users, one every time they access the page. They will type
their alias (a short name) and the result of the operation, and for that they
should use only mental calculation. After they send the data, a success or
failure result will be presented.
In order to motivate the users, we will also introduce some simple
gamification techniques: a ranking of users based on points they get when
they try the calculation every day, and also when they succeed. We will
show this on the results page.
This is the main idea of the whole application we will build (our vision)
and this book will emulate an Agile way of working in which requirements
come in the form of user stories. Agile, in spite of being criticized by many
software developers, has become the standard methodology applied in

© Moises Macero 2017 9


M. Macero, Learn Microservices with Spring Boot,
https://doi.org/10.1007/978-1-4842-3165-4_2
Chapter 2 The Basic Spring Boot Application

a vast majority of IT companies. The reality is that, when implemented


properly, it’s a way of working that allows teams to deliver software that
can be used as early as possible and to get a valuable feedback out of it.
Supported by Agile, we start simple, and then we build on top of that.
Consider the first user story here.

USER STORY 1

As a user of the application, I want to be presented with a random


multiplication that I can solve online—not too easy, so I can use mental
calculation and make my brain work every day.

To make this work, we’ll split the user story into several sub-tasks:

1. Create a basic service with the business logic.

2. Create a basic API endpoint to access this service


(REST API).

3. Create a basic web page to ask the users to solve that


calculation.

The Skeleton App


Skinny vs. Real-Life Apps
The first thing you’ll find if you search Spring Boot tutorial on Google is
the Getting Started guide from Pivotal (see https://spring.io/guides/
gs/spring-boot/). Following the guide, you can build a Hello World
(or Greetings) app, but that’s not exciting when you already have some

10
Chapter 2 The Basic Spring Boot Application

experience in software development. If you look for something more


challenging, you’ll find yourself diving into many other official Getting
Started guides that, despite being really useful, are totally disconnected
and don’t provide real-life code examples. They help you build skinny
apps.
Don’t take this wrong: these guides are very useful for daily work. For
example, you may not remember how to set up a RabbitMQ listener, and
in that case, you can scan these guides for a quick answer. The main goal
of such guides is to provide you with a quick example (that normally might
take around 15 minutes) that covers the basics you need to set up the
different functionalities of Spring Boot. Because of that, the applications
are sometimes built with shortcuts, like having all the code in the same
class or inserting data through command-line runners.
As you already know, the objective of this book is to help go further,
using Spring Boot to build applications that are closer to real-life cases.
You learn how to combine the different technologies together and set up
a code with no shortcuts, following good practices and including a proper
testing coverage.

C
 reating the Skeleton
Hands-on code! The first thing you do is create a Spring Boot application
skeleton that will serve as the reference during the book. There are several
ways to do this. Navigate to the Spring Initializr web site at http://start.
spring.io/ and generate a project from there (see Figure 2-1).

11
Chapter 2 The Basic Spring Boot Application

Figure 2-1. The Spring Initializr web site helps you create a basic
application

Let’s give some values to the Group (microservices.book) and to the


Artifact (social-multiplication). Now click on Switch to the Full Version
and change the package name to microservices.book.multiplication.
Enter a custom description if you want. Then, under dependencies, select
Web. The last step is to select the Spring Boot version, 1.5.7 in this case.
That’s all you need for now. Leave the other settings as they are, as you’ll
work with Maven and Java.
Generate the project and extract the ZIP contents. The social-
multiplication-­v1 folder contains everything you need to run your app,

12
Chapter 2 The Basic Spring Boot Application

including a Maven wrapper (mvnw) that you can execute from the source
folder. If you prefer, you can use your own Maven installation instead.
Now you can use your favorite shell to run the application with this
command:
$ mvnw spring-boot:run

Your application will start. The last line you should see there is
something like this:

m.book.SocialMultiplicationApplication   : Started
SocialMultiplicationApplication in 2.385 seconds
(JVM running for 6.07)

This app, as you might have guessed, is not practical yet. There is
no functionality in there, even though it’s occupying a port at 8080. But
it’s useful to generate the skeleton project this way, having the Maven
configuration in place and the root packages.

RUNNING THE SPRING BOOT APP

From here onward, it will be assumed that you know how to run the Spring
Boot application. It’s also recommended that you use your preferred IDE to
work with the code or import the Maven projects (Eclipse, IntelliJ, Spring Tool
Suite, etc.). The most popular IDEs have good integration with Spring Boot and
Maven and allow you to run it directly without typing anything in the command
line. If you need more help with this, just visit the official guides for these
integrated development environments.

Warming Up: Some TDD in Action


Test-driven development is based on writing the application tests before the
main code logic, making these tests fail first, and then writing the code to
make them pass.

13
Chapter 2 The Basic Spring Boot Application

WHY IS TDD GOOD FOR DEVELOPERS?

There are many reasons why, but the most important one is that TDD forces
you and the business person to think about the prerequisites in a deeper way.
This includes thinking about what the code should do under certain situations
or use cases. It will help you clarify vague prerequisites and reject invalid ones.

However, there is one idea usually associated with TDD that sometimes is
taken to the extreme: continuous refactoring of code in several iterations.
You should find a balance—it’s not a good idea to write poor quality,
unmaintainable code just to make the tests pass and then later refactor them.

Let’s start thinking about what we need. We’ll start with


MultiplicationServiceTest, in which we want to check that a
Multiplication has been generated. The Multiplication class is shown
in Listing 2-1.

SOURCE CODE AVAILABLE WITH THE BOOK

You can find the code in this chapter in the v1 repository on GitHub at
https://github.com/microservices-practical.

Listing 2-1. Multiplication.java (social-multiplication v1)

package microservices.book.multiplication.domain;

/**
* This class represents a Multiplication in our application.
*/
public class Multiplication {

14
Chapter 2 The Basic Spring Boot Application

    // Both factors


    private int factorA;
    private int factorB;

    // The result of the operation A * B


    private int result;

    public Multiplication(int factorA, int factorB) {


        this.factorA = factorA;
        this.factorB = factorB;
        this.result = factorA * factorB;
    }

    public int getFactorA() {


        return factorA;
    }

    public int getFactorB() {


        return factorB;
    }

    public int getResult() {


        return result;
    }

    @Override
    public String toString() {
        return "Multiplication{" +
                "factorA=" + factorA +
                ", factorB=" + factorB +
                ", result(A*B)=" + result +
                '}';
    }

15
Chapter 2 The Basic Spring Boot Application

Simple. It’s a basic class, and it contains the result as well. There is no
need to calculate it all the time across the application.
We define also the service interface, as shown in Listing 2-2.

Listing 2-2. MultiplicationService.java (social-multiplication v1)

package microservices.book.multiplication.service;

import microservices.book.multiplication.domain.Multiplication;

public interface MultiplicationService {

    /**
     * Creates a Multiplication object with two randomly-­
generated factors
     * between 11 and 99.
     *
     * @return a Multiplication object with random factors
     */
    Multiplication createRandomMultiplication();

Also, because we want to generate random multiplications, we create a


service to provide random factors (see Listing 2-3). That will help us write
proper tests; it would be much more difficult if we use Random inside the
service implementation.

Listing 2-3. RandomGeneratorService.java (social-multiplication v1)

package microservices.book.multiplication.service;

public interface RandomGeneratorService {

16
Chapter 2 The Basic Spring Boot Application

    /**
     * @return a randomly-generated factor. It's always a
number between 11 and 99.
     */
    int generateRandomFactor();

Once you have the interfaces you need, you can write the first test
version, as shown in Listing 2-4.

Listing 2-4. MultiplicationServiceTest.java (social-­multiplication v1)

package microservices.book.multiplication.service;

import microservices.book.multiplication.domain.Multiplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.junit4.SpringRunner;

import static org.assertj.core.api.Assertions.assertThat;


import static org.mockito.BDDMockito.given;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MultiplicationServiceTest {

    @MockBean
    private RandomGeneratorService randomGeneratorService;

    @Autowired
    private MultiplicationService multiplicationService;

17
Chapter 2 The Basic Spring Boot Application

    @Test
    public void createRandomMultiplicationTest() {
        // given (our mocked Random Generator service will
return first 50, then 30)
        given(randomGeneratorService.generateRandomFactor()).
willReturn(50, 30);

        // when
        Multiplication multiplication = multiplicationService.
createRandomMultiplication();

        // then
        assertThat(multiplication.getFactorA()).isEqualTo(50);
        assertThat(multiplication.getFactorB()).isEqualTo(30);
        assertThat(multiplication.getResult()).isEqualTo(1500);
    }
}

The @MockBean annotation is important in this test: it tells Spring to inject


a mock of the RandomGeneratorService bean, instead of letting it search for a
suitable implementation of the interface (which doesn’t exist yet).
We’re using some benefits of both Mockito and Spring Boot to make a
simple, concise unit test. We’re also using behavior-driven development
(BDD, supported by MockitoBDD) to define what should happen when
RandomGeneratorService is called. That makes the test even easier to read,
which is great for the goal we have: getting help from the person defining
our requirements to build the use cases.
If we only write these three classes and execute the test, it will
obviously fail, since there is no implementation of MultiplicationService
to test. Again, that’s exactly the point of TDD—we wrote the specs first,
then validate those with a business analyst (like a Product Owner in
Scrum; see https://tpd.io/prd-own), and then list which other cases
should be covered. All of this with no implementation of the solution.

18
Chapter 2 The Basic Spring Boot Application

Once the test (requirement) is clear, we write the solution, as shown in


Listing 2-5.

Listing 2-5. MultiplicationServiceImpl.java (social-­multiplication v1)

package microservices.book.multiplication.service;

import microservices.book.multiplication.domain.Multiplication;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
class MultiplicationServiceImpl implements
MultiplicationService {

    private RandomGeneratorService randomGeneratorService;

    @Autowired
    public MultiplicationServiceImpl(RandomGeneratorService
randomGeneratorService) {
        this.randomGeneratorService = randomGeneratorService;
    }

    @Override
    public Multiplication createRandomMultiplication() {
        int factorA = randomGeneratorService.
generateRandomFactor();
        int factorB = randomGeneratorService.
generateRandomFactor();
        return new Multiplication(factorA, factorB);
    }
}

19
Exploring the Variety of Random
Documents with Different Content
III.

Tultuamme iltapäivällä leiriin totesimme, että tasavallassa oli kapina.


Se oli vaikuttanut rautatierakennuksen hallintoon ja työmiehiin, jotka
muodostivat valtion valtiossa. Miehistön huonoin aines oli mennyt
kapinoitsijain puolelle, mutta joutui heti tappiolle. Osa kaatui, toiset
pakenivat de los Andesiin. Molemmat puolueet olivat yhtenä
miehenä roistoja vastaan. Rautatie oli molempien puolueiden
yhteisen isänmaan omaisuutta. Toverit olivat ennättäneet vähän
ennen meitä leiriin. Rautatien rakennustyö oli keskeytetty. Leirissä oli
hiljaista. Seuraavana päivänä saapui tasavallan molempien
puolueiden sotamiehiä vahdin pitoon.

Parin päivän kuluttua matkustimme alamäkeä Limaan ja edelleen


Callaoon. Siellä täällä näkyi sotamiehiä vartioimassa rataa. Me neljä
toverusta ja Chimb istuimme yhdessä koko junamatkan. Chimb aikoi
jäädä Limaan tai jatkaa Callaoon, riippuen siitä, missä parhaiten
tarvittiin haavoittuneiden hoitajia. Matka oli monivaiheinen. Väliin
juna luisui kiskoilta, väliin oli vesikaivo eli oikeastaan kuoppa
kuivunut tyhjäksi, jolloin miehissä kannettiin veturiin vettä puolen
virstan takaa.
Viimeinen ja jännittävin tapaus ennen Limaan tuloamme oli
seuraava. Oli pitkä alamäki, jossa rautatie kulki korkeiden puusiltojen
ja syvien rotkojen poikki rakennettujen riippusiltojen yli. Se puoleksi
katettu vaunu, jossa me viisi ystävystä olimme, oli junan
loppupäässä. Vain kaksi avonaista vaunua oli takanamme. Yht'äkkiä
rupesi juna kulkemaan kovemmin. Huomasimme, että viimeisen
vaunun jarru oli lakannut toimimasta vähän matkan päässä
korkeasta puusillasta jota ennen rautatie teki jyrkän mutkan
vasempaan.

— Hypätään alas, sanoi Charley.

— On jo myöhäistä hypätä, sanoi Chimb.

Odotimme joka sekunti, että juna suistuisi rotkoon. Mutta niin ei


käynyt. Sivuutimme sillan kunnialla, ja aioimme hypätä junasta.
Miettiessämme ja valitessamme parasta paikkaa mihin loikata,
lisääntyi junan vauhti syystä, että toisenkin vaunun jarrulaite oli
särkynyt. Nyt juna kulki ihan vimmatusti pitkät matkat, kuitenkaan
suistumatta kiskoilta. Ajattelimme jo, ettei se aiokaan suistua, koska
joku korkeampi voima on toisin päättänyt.

— Jos vielä säilymme puolen virstan verran, olemme pelastetut,


sanoimme me miehet.

— Pitäkää pojat varanne, kohta tämä leikki loppuu. Ensimmäisessä


käännöksessä oikealle menemme nurin. Nyt! Chimb, joka oli
ennustanut nurinmenoa, antoi merkin ja hyppäsi ensin junasta ja me
heti hänen jäljestään.

*****
Tuli pian ilta ja pimeä. Emme voineet tehdä mitään sinä päivänä.
Totesimme vain, että olimme eheät. Ruokaa Chimbillä oli riittävästi
meille kaikille viidelle; ei siis hätää pariin vuorokauteen. Muista
emme välittäneet. Seuraavana aamuna päivän valjetessa aloimme
korjata rataa ja nostaa kiskoille kelvollisia vaunuja; rikkinäiset saivat
jäädä tien viereen. Veturi oli eheä. Kolmantena päivänä puolipäivän
aikaan saavuimme Limaan. Liman ja Callaon välinen rataosa oli
epäkunnossa. Jatkoimme siis tuon viidentoista virstan lopputaipaleen
jalkaisin. Seuraavana aamuna heräsimme mr. Michel Kellyn boarding-
housissa (matkustajakoti merimiehiä varten). Me neljä olimme
nukkuneet samassa huoneessa, mutta Chimb erikseen.

Michel Kelly oli yksi noita tavallisia verenimijöitä, joita siihen aikaan
tapasi — ja kukaties nytkin tapaa — kaikissa satamakaupungeissa.
Hänen ammattinansa oli nousta vasta saapuneeseen laivaan
houkuttelemaan miehistöä karkaamaan. Useimmiten joku tarttui
onkeen. Nämä poistuivat laivasta vähää ennen sen lähtöä ja
piilottelivat, kunnes laiva oli jättänyt sataman. Sitten boardingmaster
möi heidät toiseen, miehien puutteessa olevaan laivaan. Yhden tai
kahden kuukauden palkan boardingmaster nosti etukäteen, olipa
mies asunut hänen luonaan pitkän tai lyhyen ajan. Tuon karanneen
miesraukan ainoa korvaus oli pari perinpohjaista humalaa,
saippuatanko ja naulan verran tupakkaa. Mutta hänen harminsa oli
se, että oli menettänyt monen kuukauden, usein vuodenkin palkan.
Boardingmastereilla oli sitä paitsi juoksukoiria, runnareja, jotka
saivat eri suuruisen maksun jokaisesta taloon hankkimastaan
miehestä, riippuen tämän arvosta ja ulkonäöstä.

Satamakaupunkien boardingmasterit ja runnarit olivat melkein


kaikki roistoja, etenkin ne, jotka harjoittivat liikettänsä Etelä- ja
Keski-Amerikassa sekä Yhdysvaltain etelävaltioissa. Mutta Michel
Kelly oli roistojen roisto. Chimbillä ei ollut valitsemisen varaa ja
hänen oli pakko viettää meidän neljän turvissa tämä ensimmäinen
yö. Syötyämme aamiaisen, johon kuului paljon ja hyvää lihaa ynnä
salaatinlehtiä sekä keitettyinä että raakoina, oli Chimb valmis
lähtemään sairaalaan Punaisen Ristin hoitajattareksi. Kaduilla kulki
sotamiehiä, ja kiväärinlaukaus kajahti silloin tällöin. Katukapakoissa
oli kaatunut muutamia kymmeniä miehiä, ja haavoittuneita oli viety
sekä Punaisen Ristin että kaupungin sairaalaan. Muuten kapina
näytti lapselliselta ja leikkisotamaiselta, niin kuin on tavallista Etelä-
Amerikan pikku valtioissa, joissa melkein joka vuosi kapinoidaan ja
nelistetään sapeleita, etteivät ne pääsisi ruostumaan. Lähdimme
kaikki yhtaikaa ja saatoimme Chimbin sairaalaan.

Tuima upseeri seisoi ovella. Hän kysyi meiltä, mitä joukkoa


olemme ja mihin puolueeseen kuulumme.

— Olemme puolueettomia Oroyan rautatien rakentajia


vastasimme.

— Onko teillä todistuksia?

— Tässä on, sanoimme ja vedimme esille likaiset, rikkinäiset


paperimme.

Chimb meni sairaalaan. Häneltä ei kysytty mitään; hänen pukunsa


ja ristinsä turvasivat hänet. Upseeri vei meidät toverukset lähellä
olevaan vahtikonttoriin, jossa rintaamme neulottiin
puolueettomuuden merkki, pyöreä messinkilevy, jossa oli "Peru".
Aloimme kävellä rantaan päin. Keskellä rantatoria oli suuri, ravistunut
ja puoleksi mädäntynyt laivanhylky. Tämä samoin kuin pari muuta
torilta jo poistettua hylkyä olivat aikoinaan komeita purjelaivoja.
Niiden ollessa satamanselällä viisi vuotta sitten, oli suunnaton
nousuveden aalto maanjäristyksen tai oikeammin merenpohjan
järistyksen yhteydessä kohottanut merenpinnan kuusi syltä tavallista
korkeammalle. Laivojen ankkurikettingit, joita ei ennätetty tarpeeksi
pian lisätä, olivat katkenneet, ja monta laivaa syöksyi aallon myötä
kuivalle maalle.

Satamassa, laituriin kiinnitettyinä, oli useita eri maista kotoisin


olevia laivoja. Nämä tulivat useimmiten pohjalastissa, muutamat
lautatavaralastissa. Puutavara on kallista Etelä-Amerikan
länsirannikolla, koska täällä ei kasva honkia eikä kuusia. Täältä, itse
Callaosta, ei viety juuri muuta kuin vähän raakoja nahkoja Pohjois-
Amerikan länsirannikolle. Mutta Callao oli määräystenantopaikka.
Täällä odottivat laivat määräystä, mihin paikkaan niiden piti lähteä
ottamaan kallisarvoista guanoa — maailman parasta apulantaa.
Tavallisimmat guanon lastauspaikat Perun rannikolla olivat siihen
aikaan Huanillas mannermaalla ja Chinsi-saaret lähellä rannikkoa.

Perun rannikko, jonka viljelykselle soveltuva alue on kapea kaistale


mahtavan de los Andesin edustalla, on erinomaisen viljava ja
hedelmällinen. Kuinka se voi olla mahdollista, kysyy varmasti se, joka
tietää, ettei Perussa de los Andesin länsipuolella koskaan sada. Siellä
ei todellakaan koskaan sada. Yökaste vain kostuttaa maan. Aamulla
auringonnousun aikana juoksee kastevesi pieninä puroina alas
vuorenrinnettä. Miksi ei Perussa de los Andes -vuorten länsipuolella
sada, on kysymys, johon ei kukaan voi antaa varmaa vastausta.
Siihen aikaan, josta nyt on kysymys, luultiin ihmeen johtuvan siitä,
että täällä aina puhaltava kaakkoispasaadi vie pilvet mukanaan
jonkin matkan päähän merenrannasta, jossa ne vasta putoavat
sateena alas mereen.
De los Andesin itäpuolella sataa kuten muuallakin maapallolla.
Ikuinen pouta pitää länsipuolelta kulkutauteja loitolla. Eiköhän Peru
liene terveellisin seutu maan päällä.

Ainoa kulkutauti, joka täällä viihtyy, on "Peruvian mountain fever"


(Perun vuorikuume). Se kestää ainoastaan pari päivää, eikä ole
tappava. Samalla leveysasteella Brasiliassa raivoaa sen sijaan
keltarutto. Sadekautta seuraavassa kuumuudessa nousee
suopaikoista höyryn mukana keltaruttomoskiitto levittäen laajalti
kauhistusta. Saavuttuamme Michel Kellyn asunnolle oli siellä hirveä
melu. Aluksi aioimme pysyä loitolla, kunnes melu lakkaisi. Mutta kun
kuului naisen huuto, joka ei voinut olla kenenkään muun kuin
Chimbin, oli aika rientää apuun. Ovi oli lukittu ja naisen huuto lakkasi
hetkeksi.

— Ei suinkaan se ollut hänen äänensä, on niitä muitakin


samanäänisiä tässä maassa, tuumi Mack.

— Olipa ääni kenen hyvänsä, naisen se kumminkin oli. Ehkä


naisparka jo on heittänyt henkensä.

— Ovi on rikottava miehissä, sanoi Charles Clark.

Ryntäsimme ovea vastaan. Se oli vahva, mutta antoi viimein


perään. Pääsimme talon päähuoneeseen, joka oli samalla sali,
ruokasali ja kokoontumishuone. Eteistä ei "hotellissa" ollut. Nurkassa
seisoi Chimb, ympärillään kolme villiintynyttä pirua, nimittäin Michel
Kelly ja kaksi runnaria. Kelly puristi Chimbiä kurkusta, ja runnarit
koettivat ryöstää hänen rahansa, jotka oli ommeltu puseron alle.

— Kestäkää vielä hetkinen, signorita, huusi Charles.


Tyttöparka ennätti huomata, että apu oli lähellä. Roiston käden
kovasta puristuksesta huolimatta Chimb antoi tälle tuntuvia iskuja
vasten naamaa. Ei olisi Chimb parka kuitenkaan enää montaa
minuuttia voinut suojella henkeänsä. Tuo entinen hienopukuinen
toverimme, rikkaan tehtaanomistajan ainoa perillinen, Oxfordin
ylioppilas ja mainio nyrkkeilijä toimi kuin salama. Onhan syystä
sanottu, ettei englantilainen gentlemanni pidä kiirettä. Mutta tällä
kertaa ei sananlasku pitänyt paikkaansa. Käden käänteessä oli Michel
Kelly saanut iskun, joka saattoi hänen kätensä heltiämään Chimbin
kurkusta. Pedot käänsivät nyt huomionsa meihin neljään ja jättivät
Chimbin rauhaan. Taistelu oli tuskin päässyt alkuun ja roistot
ruvenneet kaivamaan esille puukkojaan, kun Charles antoi
molemmille runnareille iskun sydänalaan. Enempää ei tarvittu.
Roistot ryömivät ovesta ulos. Kadulla kulkevalle sotilaspatrullille he
kertoivat koettaneensa vangita meidät kapinallisina…
IV.

Kauankohan meidän on oltava täällä? sanoi Charley, kun olimme


lähes vuorokauden istuneet eli oikeastaan maanneet päävahdin
kovalla lattialla, ainoana ravintona vesi, jota oli tuotu sangollinen
ennen kuin ovi lyötiin kiinni.

— Kaikki tämä on minun syytäni. Eihän minulla ollut mitään asiaa


Kellyn taloon, mutta katsoin velvollisuudekseni saada selvän
olinpaikastanne, jotta tarpeen tullen pääsisin avuksenne.

Olimme kaikki sitä mieltä, ettei henkemme ollut paljon arvoinen.


Milloin tahansa saattoi ovi aueta ja tulla komennus takapihalle
ammuttaviksi.

— Voi, ettemme jääneet Limaan! Siellä olisimme olleet


paremmassa turvassa. Varmaankin mr. Malcolmin asuntoa vartioi
kaarti; sen läheisyydessä olisi ollut turvallista olla. Yhdysvaltain lippu
liehuu siellä niin korkeassa tangossa että se näkyy yli koko
kaupungin. Castela Martan — tämä linna on varmaan hallituksen
miesten vallassa — lippu tosin liehuu lähellä edellä mainittua lippua,
mutta mitäpä se merkitsee tähtilipun rinnalla! Kun vain pysyisi tuo
ovi aukenematta päivän eli pari, niin vaara olisi ohi. Näissä maissa
eivät kapinat ole pitkäaikaisia, sanoi Chimb.

— Kaikki muu on yhdentekevää, kunhan vain saisin ruokaa. Kurjaa


on muuttaa toiseen maailmaan tyhjin vatsoin, sanoi Mack
Henderson.

Sangosta oli vesi loppumaisillaan. Tilanne alkoi käydä


sietämättömäksi, jonka vuoksi päätimme nostaa melun, jotta siten
saisimme vartijat aukaisemaan oven. Sitten hyökkäisimme
henkemme kaupalla ulos; kuolemahan meitä kuitenkin odotti.

— Odotetaan vielä puoliyöhön saakka. Sitten koetamme loikata


ulos tuosta ikkunasta ja paeta. Tosin siinä on rautaristikko, mutta se
on ihan seinän ulkoreunassa, siis ainoastaan vanhan ränsistyneen
rappauksen varassa, sanoi Chimb.

Päätimme noudattaa Chimbin ehdotusta, mutta Mack Henderson


oli toista mieltä.

— Minä en aio odottaa puoliyöhön, vaan rupean huutamaan ja


potkimaan ovea. Koetan repiä irti tuon vanhan rautaristikon; toisin
sanoen teen vaikka mitä, ennen kuin kuolen nälkään tässä
vankilahelvetissä.

Tunnit kuluivat hitaasti. Odotimme joka hetki oven aukaisua ja


komennusta seinää vasten. Kovalla tiililattialla loikominen teki
jäsenet kipeiksi. Olihan mahdollista, että oven aukeneminen
merkitsisi vapauttakin.

— Vapautta minä en enää odota, kun ei sitä jo ole tullut. Yö on


kohta puolessa. Rukoilkaa pojat, ehkä se auttaa.
— Minä puolestani olen rukoillut jo tuntikausia ja uskon pääsemme
täältä hengissä, sanoi Chimb.

— Rukoilkaa, signorita, esi-isienne Suurta Henkeä tulemaan


avuksemme — ei meidän jumala ainakaan nyt kuule rukouksiamme,
sanoi Mack Henderson.

— Pidä suusi kiinni, Mack! Sinä, joka ennen olet ollut hyvä toveri
ja harvapuheinen, olet yht'äkkiä muuttunut hävyttömäksi ja
suurisuiseksi. Jollet nyt ole vaiti ja tottele meitä, niin jätämme sinut
tänne.

Semmoinen oli se lyhyt saarna, jonka pidimme Mackille. Se


näkyikin auttavan. Ei sanaakaan tullut pojan suusta puoleen tuntiin.
Hän vain silloin tällöin veti syvään henkeään. Kysyimme, oliko hän
sairas, mutta emme saaneet vastausta. Raapaisimme tulta tikulla ja
katsoimme kelloa Se oli neljänneksen yli kahdentoista.

— Nyt pojat! sanoi Chimb. — Minä alan hiljaa röykyttää ristikkoa.

Se liikkui. Silloin rupesi oven takaa kuulumaan ääniä ja raosta


näkyi lyhdyn valoa. Samassa pistettiin iso avain lukkoon. Charley
nykäisi minut pois ikkunan kohdalta ja alkoi riivatusti röykyttää
ristikkoa. Oven aukaisija ei saanutkaan lukkoa toimimaan. Voiteen
puute oli suonut ruosteen rauhassa kasvaa. Kirouksia kuului oven
takaa. Sitten toinen mies rupesi tekemään parastaan. Väänsi
eteenpäin ja taaksepäin, samalla mainiten helvetin pyhimysten
nimiä. Mutta ovi vain pysyi kiinni. Sitten kuului, kuinka molemmat
"lukkosepät" poistuivat apua noutamaan. Chimb rukoili.

— Kiitos sinulle, Suuri Henki, joksi lapsuudessani Jumalaa


kaikkivaltiasta sanoivat, että annoit ruosteen kasvaa lukossa! Toivon,
että tuo ristikko samoin on siunatun ruosteen vallassa. Pelasta nuo
nuoret miehet. Kaikkivaltias, heitä tarvitaan Oroyan rautatien,
isänmaani suuren rautatien rakennustyössä. Pelasta myös minut, jos
niin hyväksi näet.

Chimborazo, joka oli ollut polvillaan tiililattialla, nousi ylös.

— Kyllä ristikko heltiää, jos vain saamme tarpeeksi aikaa. Minä


lepään vähän sillä välin kun te toiset vuoroonne röykytätte.

Röykytimme vuoron perään ristikkoa; lovet suurenivat


suurenemistaan. Ristikon täytyi viimein jättää meille vapaa pääsy
ulos. Oli ihme, ettei ketään ilmestynyt ulkopuolelle, ei asiattomia eikä
asiallisia, vaikka aikaansaamamme melun olisi pitänyt havahduttaa
kuolleetkin, jos niitä oli "hotellin" seinien sisällä. Mack Henderson
teki työtä yhtä uutterasti kuin oli tätä ennen haukkunut. Olin
ristikkoa röykytettyäni ottanut levähdyshetken, kuinka monennen —
en muista, ja tarjonnut työtä toisille. Mutta koska ei kukaan heti ollut
valmis käymään kiinni, astui Chimb, edeltäjäni vuorossa, taas
työhön. Katsottiin kelloa — tulitikkuja oli jäljellä viisi — se näytti
puolta kahta. Chimb röykytti taas vimmatusti ja hengitti läähättäen.
Sitten hän rupesi röykyttämään harvaan ja hiljakseen. Nyt taitavat
Chimbin voimat olla lopussa, ajattelimme. Hän astui pois ikkunan
edestä ja sanoi:

— Nyt pojat lähdemme! Ristikko on irti. Ei tarvitse muuta kuin


työntää se ulos.

Sytytettiin yksi jäljellä olevista viidestä tulitikusta. Katseltiin ja


koetettiin, olivatko rahamme tallella. Ne olivat kunkin paidan alla
pussissaan, ommeltuina rinnan kohdalle. Miehillä oli myös housujen
takataskussa nahkakotelon sisässä revolverinsa. Chimbin pieni ja
tehokas pistooli oli vaatteiden alla, vyötäisten yläpuolella. Chimb
työnsi ristikon alas, ja se helähti pudotessaan kiveä vastaan. Ensin
hyppäsi Charley, sitten Fred, sitten Chimb ja viimeiseksi minä. Ensin
katselimme ympärillemme vähän aikaa ja sitten syöksyimme, Chimb
etunenässä, niin kovaa kuin pimeässä taisimme, matalaa muuriaitaa
kohti, jonka yli helposti pääsimme. Nyt rupesi takaamme kuulumaan
väkivasaran paukutusta. Särjettiin ovea, jonka ruostunut lukko oli
meidät pelastanut.

Vanha laivahylky, joka oli kyljellään ylähangan puolella keskellä


satamatoria, oli merkkinä. Se näkyi läpi pimeän ja sumun ja ikään
kuin viittasi meille: tänne päin! Päästyämme laivahylyn ohi se suojasi
tietämme laivarantaan vihollisten luodeilta.

— Ketä siellä?! huudettiin saksalaisesta laivasta, joka oli kiinnitetty


laituriin.

— Pyydämme nöyrimmästi suojaa, sanoi Fred saksan kielellä.

— Ja ruokaa, sanoi Mack englannin kielellä. Laivan kapteeni, joka


tänä levottomana aikana sattui olemaan valveilla, suostui laskemaan
meidät laivaan, kuultuaan, kuinka laitamme oli. Saimme paikan
kannen alla laivan peräpuolella. Tämä maan- eli oikeastaan
vedenalainen komero oli tyhjä. Sitä käytettiin tarpeen vaatiessa
sairaalana. Kun olimme saaneet piilopaikkaamme ruokaa ja vettä,
nostettiin luukku aukon päälle ja tämä peitettiin köysirojulla. Onneksi
ei ketään ollut näkemässä tuloamme rantaan ja laivaan.

— Kauankohan tässä vieraskodissa saamme istua?!


Annetaankohan täällä niin runsaasti ruokaa, ettei kuole nälkään?
Alku on ainakin hyvä, australialaista säilykelihaa ja hyviä
laivakorppuja, en nähnyt ainoatakaan matoa. Siinä tietenkin tein
väärin, että tarkastin. Eivät madot minua haittaa, kun eivät vain
päälle tuppaa tulemaan. Mikähän aukko tuossa lautaseinässä on?
Kyllä sen arvaankin, siitä hän pääsee lastiruumaan, joka nyt on
tyhjä. Ehkä saksalaiset pitävät meistä huolen, vaikka en minä heihin
paljon luota. Onhan Fred saksalainen, siitä on meille etua.

Mackin lopetettua sanoi Fred:

— Minun saksalaisuudestani ei ole paljoakaan apua, ainakaan


itselleni; päinvastoin. Olen karannut kaikkien saksalaisten
jumaloimasta sotalaivastosta, ja istun täällä kuin ruutitynnyrillä,
johon johtavan sytytyslangan toinen pää jo käryää.

— Kyllä Jumala meidät täältäkin auttaa, kun vain rukoilemme


hartaasti, sanoi Chimb.

— Kyllä kai se oli teidän esi-isienne "Suuri Henki", joka auttoi


meidät "kortekaalista", sanoi Mack.

Charley pudisti nyrkkiään Mackille, sanoen:

— Pidä jo suusi kiinni, muuten…

— Olkaa hiljaa, pojat, tämä puhehan voi kuulua ympäri koko


laivan, vieläpä maihinkin, sanoi Chimb.

— Liittomme näyttää veisaavan viimeistä virttään. Minä ehdotan,


että heti kun tästä pulmasta pääsemme, Mack kulkee omaa tietään,
sanoi Fred.

Lamppu, jota oli muutettu paikasta toiseen, sen mukaan kuin sitä
paraiten tarvittiin, putosi lavitsalta lattialle. Onneksi se sammui eikä
särkynyt sytyttäen tulipaloa. Tulitikkumme eivät syttyneet. Hetken
hiljaisuus.

— Nyt ei voi muuta kuin istua tai maata pimeässä ja tyytyä


kohtaloonsa, kunnes joku laivan miehistä tulee tänne. Se voi kestää,
mutta tuleehan joku viimein, sanoi Chimb.

Oli kulunut monta tuntia pimeässä, mutta koko aikana ei ollut


sanottu monta sanaa. Chimb huomautti, että yhden meistä aina oli
pidettävä vahtia, etteivät rotat hyökkäisi kimppuumme. Niitä tulikin
tuon tuostakin lastiruumasta ihan päällemme. Oli kaiken aikaa hiljaa
lattiata polkemalla peloitettava niitä. Yhden rotan, joka oli muita
rohkeampi, Fred potkaisi kuoliaaksi. Tämän vingahtaessa kuului
ruumasta rottapataljoonan vingahduksia vastaukseksi. — Pidetään
varamme! Nämä satama- ja laivarotat ovat kostonhimoisia, sanoi
Chimb.

Kuului sihinää ja hiljaista vikinää. Kerkisimme juuri nousta


seisoallemme, kun tusinan verran rottia ilmestyi ympärillemme.
Nämä kauhean iljettävät pedot kiipesivät salaman nopeudella ylös
pitkin ruumistamme. Oli täysi työ saada ne putoamaan lattialle.
Kuinkahan olisikaan käynyt, jollei yht'äkkiä olisi tullut kaksi miestä
lyhdyt kädessä ruumasta aukolle! Rotat hävisivät kuin salama.

— Emme muistaneet sanoa teille, että täällä on noita rottapetoja.


Eivät kai ole puraisseet rikki kenenkään nenää tai korvia? Jos joku
tukkihumalainen mies makaisi täällä, niin rotat söisivät hänet. Niillä
on tapana aloittaa nenästä ja korvista. Kuulkaa nyt, mitä meillä on
sanottavaa ja kerrottavaa teille. Tämä yö on ollut hyvin rauhaton.
Ampumista on kuulunut monelta haaralta. Laiturilla sivullamme on
kävellyt partio koko yön. Se tuli tänne vähän sen jälkeen, kun
saimme teidät lastatuiksi laivaan. Eräs upseerimies on käynyt kaksi
kertaa kysymässä, onko täällä näkynyt neljää miestä ja yhtä naista;
ne ovat kapinallisia. Sitten tuli tänne taas muuan toinen upseeri
mukanaan satamamestari ja antoi määräyksen meille samoin kuin
noille kahdelle toisellekin laivalle lähteä satamanselälle ankkuriin.
Hinaaja laivan pitäisi tulla tunnin kuluessa viemään meidät
soveliaaseen paikkaan.

Meille tuotiin laivakorppuja ja säilykkeitä sekä kattilallinen teetä.


Lamppu oli kunnossa ja loisti niin kuin senaikaiset laivalamput
loistivat Kuulimme kannelta hälinää ja viimeksi kuulimme
hinaustouvin luisuvan laivan kokasta hinaajalaivaan. Muutamia
komennussanoja, ja laiva tuntui olevan irti laiturista.

— Mennäänkö nyt hiiteen vai helvettiin? kysyi Mack Henderson,


oltuaan vaiti tuntikausia.

— Ette te muut joudu hiittä pitemmälle, toista on minun poloisen.


Jos tänne tulee saksalainen sotalaiva, mikä on otaksuttavaa —
niitähän aina risteilee näillä levottomilla Tyynenmeren itärannikoilla
turvaamassa Saksan alamaisia — niin minä joudun helvettiin, sanoi
Fred.

Laiva lakkasi kulkemasta, ja ankkuri meni kovalla rytinällä ja


kolinalla pohjaan, vieden paljon kettinkiä mukanaan. Tällä rannikolla
ei ole oikeastaan mitään niemien tai saarien suojaamia
satamapaikkoja, vaan valtameri on heti edessä. Satamanselkänä on
ääretön Tyvenmeri. Eikä täällä niemien ja saarten piirittämiä
satamanselkiä tarvitakaan koska aina puhaltaa maatuuli, hiljainen
kaakkois-pasaadi. Ilma on kaunis aina. Vuodenajoista ei tiedetä
mitään, syystä ettei koskaan sada. Laivat ovat ankkurissa syvässä
vedessä, minkä vuoksi kettinkiä on ulkona noin kolme kertaa
enemmän kuin tavallisissa ankkurisatamissa.
Kului vähän aikaa, ennen kuin saimme nousta kannelle.
Hinaajalaivanhan täytyi lähteä pois ensin, muuten sen miehistö ja
luotsi olisivat nähneet meidät. Laiva oli komea parkkilaiva nimeltä
Cuxhaven, rakennettu Cuxhavenissa. Kapteeni oli ainoa saksalainen
laivassa. Upseereista ensimmäinen perämies oli skotlantilainen ja
toinen perämies australialainen. Kolmas perämies ja saksalaiset
merimiehet, joita oli puolet miehistöstä, olivat karanneet Callaossa.
Toinen puoli miehistöä, joka oli brittiläisiä, oli jäänyt laivaan. Siis
laivassa oli vain puolet välttämättömästä miesluvusta.

— Hyvää huomenta! Kuinka olette nukkuneet? kysyi laivan


kapteeni hyvällä englannin kielellä, kun nousimme ihmisten ilmoille.

— Ei puhuta nukkumisesta, herra kapteeni. Arvaattehan, että


olemme sotineet rottien kanssa koko yön. Mutta mitäpäs niistä,
kiitämme teitä sydämen pohjasta pelastuksestamme! Nahkamme
säilyi toistaiseksi.

— Miksi toistaiseksi? Minulla on teille ehdotus, jonka mielestäni


pitäisi tyydyttää ainakin teitä miehiä, ehkäpä myös signoritaa,
sairaanhoitajatarta. Heittäytykää levolle, kun olette peseytyneet.
Vettä, Perun vuoripuroista, meillä on viljalti.

Nukuttuamme muutaman tunnin — kanssissahan oli seitsemän


vapaata makuusijaa — havahduimme kuuden lasin lyömiseen. Kello
oli kolme.

— Päivälliselle! huusi kokki.

Me neljä söimme telttakatoksen alla kanssin kokkapuolella. Chimb,


joka oli nukkunut karanneen kolmannen perämiehen hytissä, aterioi
kajuutassa herrojen kanssa. Aterian päätyttyä istuimme kaikki viisi
kannella nauttien ihanasta ilmasta.

— Mitähän se kapteeni aikoo ehdottaa meille? sanoi Chimb.

— Ei ole vaikea arvata! Hän aikoo pyytää meitä pestautumaan


karanneiden miesten sijaan, minä sanoin.

— Ei suinkaan minua, sanoi Chimb.

— Kukapa tietää. Laivassa on ainakin yksi nainen.

— Mitä sinä nyt lörpöttelet, West. Eihän täällä ole muita saksalaisia
kuin kapteeni itse, ja upseereilla ei ole lupa ottaa vaimoansa mukaan
merimatkalle, mutisivat toiset.

Kuitenkin olin nähnyt vilahdukselta nuoren naisihmisen pistävän


päänsä esiin kajuutan takaa, meidän noustessamme rotanluolasta.

— Ei päivällispöydässä ainakaan naisihmistä esiintynyt, sanoi


Chimb.

— Kyllä täällä nyt vain on laivaan kuuluva nainen.

Istuessamme mietteissämme tuli luoksemme kapteeni kaunis nuori


nainen kainalossaan.

— Minä olen kapteeni Franck ja tämä on tyttäreni.

Me sanoimme myös nimemme, joten esittäytyminen oli suoritettu.

— Suostuisitteko ottamaan pestin laivaani? Kun määräys tulee,


olen valmis lähtemään johonkin guanon lastauspaikkaan ja sieltä
guano-lastissa Eurooppaan.
— Emme tänään voi antaa teille vastausta, kapteeni, sanoin.

— Niinpä niin. Tuumikaa asiaa, hän sanoi.

Kävelimme ympäri laivassa, joka oli todella komea ja hyvin


hoidettu alus, tutustuimme miehistöön sekä ensimmäiseen ja toiseen
perämieheen — kolmashan oli karannut. Kaikki olivat mielestämme
reilun näköisiä ja mukavia miehiä. Kapteenin tytär Teresia tuli ujosti
Chimbin luo ja otti hänen kätensä.

— Saanko olla ystävänne, signorita? — Saanko minäkin olla teidän


ystävänänne? sanoi Chimb.

Molemmat tytöt menivät laivan peräpuolelle ja näkyivät vähän


ajan perästä istuvan käsikoukussa kajuutan katolla vilkkaasti
keskustellen. Ensimmäinen perämies ilmestyi keskikannelle
kalanpyydysvehje kädessään.

— Kokki, tulepas tänne kalanperkausvehkeinesi!

— Tulen, herra ensimmäinen perämies. Nyt alkoi kalanpyynti ilta-


ateriaa varten. Laivan sivu oli täyteen sulloutunut lentokaloja. Nämä
kalat ovat suuruudeltaan, näöltään ja maultaan samanlaisia kuin
meidän järviemme siiat, se ero vain, että evät ovat suuret kuin
linnun siivet ja on niiden taso samansuuntainen ruumiin kanssa eikä
poikittainen, kuten meidän kalojemme. Lentokalat hyppäävät
vedestä korkealle ja lentävät pitkät matkat suurien kalojen
ahdistamina. Purjehtiessa niitä ei voi pyydystää millään tavalla,
vaikka niitä ehtimiseen näkee lentävän.

Lentokalan pyydyksenä käytetään rautaristikkoa, jonka keskellä


olevaan tuppeen on kiinnitetty varsi. Vastakkaisella puolella ristikkoa
on kahdeksan väkäpiikkiä. Kalat ovat ihan lähellä vedenpintaa vieri
vieressä. Kun pyydys lasketaan omalla painollaan kalaparveen,
tarttuu sen joka väkään kala. Muutamassa minuutissa oli tuulastettu
lentokaloja riittävästi illalliseksi. Vähän loitommalla laivan sivusta
uiskenteli petokaloja. Mainittakoon niistä barakuto, noin puolen tai
koko metrin pituinen, hauen näköinen ja makuinen petokala.
Lentokalat pakkautuvat kiinni laivan sivuun, eivätkä lähde siitä
hätyyttämälläkään. Sitä vastoin petokalat ovat arkoja, eivätkä uskalla
tulla laivan sivulta ottamaan saalista.

Päivä alkoi mennä mailleen. Suuri, komea, punainen kuningatar


aurinko ei ollut enää kuin korennon korkealla äärettömyyttä
muistuttavan taivaanrannan yläpuolella. Laivan kannet oli
puhdistettu. Monet kymmenet taklaasiin johtavat, purjeiden ja
raakapuiden hoitoon ja johtoon kuuluvat köydet oli kääritty
nauloihinsa. Keskikansi oli tilava. Siinä olisi ollut tilaa vaikka tanssia
franseesia. Molemmat nuoret naiset tulivat, kädet toistensa
vyötäisillä, alas kajuutan katolta. Ylähangan puoleisessa kajuutan
kulmassa heitä vastaan tuli kapteeni, menossa peräkannelle. Tytär
kuiskasi muutamia sanoja isälle, joka katseli totisesti ja kieltävästi
lapseensa. Tytär katsahti vielä kerran, ihan kuin ohimennen, isäänsä,
mitään sanomatta. Silloin kapteeni veti suunsa hymyyn ja silitti tytön
kiharoita. Chimb toi Teresian luoksemme ja esitti meidät hänelle
meidän seisoessamme nojautuneina alahangan reilinkiä vastaan ja
katsellessamme aurinkoa, jonka alalaita juuri kosketti vettä.

Alkoi kuulua jouhisoittimien viritystä. Kajuutan katolla istuivat


kapteeni ja hänen molemmat upseerinsa. Kapteenilla oli suuri
harppu edessään, ja upseereista toisella sello ja toisella viulu. He
nousivat seisomaan ja soittivat iltarukouksen, johon laivamiehet,
lakki kädessään, ja Teresia yhtyivät. Kun viimeinen sävel oli vaiennut,
oli aurinkokin lakannut näkymästä. Pieni Chimb oli langennut
polvilleen liikutuksesta. Olihan hän Limassa ollessaan kuullut soittoa
ja laulua, ja hänellä oli itselläänkin kaunis ääni. Mutta on sentään
toista kuulla soittoa laivassa, jolla on valtameri kaikupohjanansa.
Sitten hän kai tunsi itsensä niin mitättömäksi tuon sivistyneen tytön
rinnalla. Teresia oli kyllä monin verroin sivistyneempi, mutta niin
vaatimaton ja antelias, että olisi lahjoittanut pois enemmän kuin
hänellä olikaan. Vähässä ajassa Chimb oli tutustunut kapteenin
tyttäreen. Teresia auttoi uuden ystävättärensä kajuuttaan saamaan
virvoitusta ja lohdutusta.

Kaakkoispasaadi, joka täällä korkeiden vuorten suojassa oli heikko,


oli nyt vastoin tavallisuutta tyyntynyt. Yökin jo lähestyi. Suurimmat
tähdet saattoi jo erottaa taivaalta. Me pakolaiset olimme ensin
päättäneet mennä aikaisin levolle, mutta emmehän mekään olleet
puusta tehtyjä, vaikka olimmekin hiljan olleet "vetäjinä", sen jälkeen
istuneet arestissa, ja viime yön viettäneet rottahelvetissä. Tähtiyö
Andeilla on suurenmoinen, mutta täällä vetten päällä se on
jumalallinen. Päätimme siis viipyä taivaan alla muutaman tunnin
iltayöstä. Kapteeni antoi meille luvan oleskella kajuutan katolla.
Chimb oli ottanut laivan prinsessan paksun huivin hartioilleen, mutta
heitti sen pian pois, sillä täällä oli yö lämmin, eikä kuten Andeilla
väliin hyvinkin viileä.

Etelä-Amerikan länsiranta on lämmin, mutta itäranta, jota vastaan


pasaadi puhaltaa, on viileä. Teresia oli pujahtanut kajuuttaan, joten
Charles ja minä jouduimme istumaan molemmin puolin Chimbiä.
Tähtien luku lisääntyi nopeasti. Etelässä matalalla näkyi komea
etelänristi, Crux australis, johon kuuluu yksi ensi luokan, kaksi toisen
luokan, yksi kolmannen ja yksi neljännen luokan tähti. Mainittu
ryhmä ei näykään tänne sen korkeammalta, koska se on Circum
Polaris. Callao sijaitsee 12°4' eteläistä leveyttä ja 77°14' läntistä
pituutta. Kuta eteläisemmällä leveysasteella ollaan, sitä
korkeammalla on etelänristi. Oli suurenmoista istua ankkurissa
olevan laivan kannella ja katsella Tyynenmeren, maailman
suurimman valtameren, avonaiselle selälle.

— Tämä hetki on suurimpia elämässäni. Vähät menneistä


koiranpäivistä! Tämä korvaa moninkertaisesti kaikki!

— Ei minulla tällä kertaa ole mitään halua Englantiin, sanoi


Charles.

Samassa tuli laivan prinsessa ja otti Charlesin paikan, mutta hän ei


pitänyt sitä kauan.

— Tulin vain sanomaan hyvää yötä. Tuletko kanssani, Chimb, vai


jäätkö kannelle?

— Luulen, että saamme maanjäristyksen tänä yönä. Minua niin


painostaa. Ei ole vallan monta vuotta siitä, kun maanjäristyksen
yhteydessä suuri hyökyaalto vei laivat tältä kohdalta Callaon torille,
sanoi Chimb.

Menimme kuitenkin muut paitsi vahti viimein nukkumaan.

— Earth quake (maanjäristys)! kuului monesta suusta samalla


kertaa. Ennen kuin kuulin tuon sanan, oli minussa hirveä vaiva. En
tietänyt, mikä minun oikein oli, mutta mielestäni koko ruumistani
tärisytti, ja olin tukehtumaisillani. Menin muiden kanssa heti ulos
kannelle. Laivan peräpuolelta kuului myös "earth quake". Kaikki
seisoivat ja katselivat toisiaan. Laiva tärisi ja mastot ja tangot sekä
koko taklaasi vapisivat niin, että luultiin niiden putoavan alas.
— Kapteeni! Pistäkää ulos kaikki kettinki molemmille ankkureille,
huusi Mack Henderson.

Kaikki miehet ja naiset kiirehtivät kokkapuolelle. Toiset nostivat


ruumasta kettinkiä ja toiset pistivät sitä ulos. Salamoita iski kaiken
aikaa. Ei tarvinnut puuhata pimeässä. Tuon tuostakin tuli aalto ja
nosti laivan kokkaa. Tunsimme, miten ankkurit kyntivät pohjaa.
Mutta tunsimme myös, kuinka ne viimein tarttuivat kiinni. Nyt ei
pelätty niin paljon "torille" joutumista, jos vain kettingit kestäisivät.
Mutta voisivathan ne katketakin.

Kettingit kestivät. Me emme joutuneet torille, emmekä edes


rantaan.

— Mack Henderson! kuului kapteeni huutavan.

— Täällä! vastasi Mack.

— Kiitos teille! Te meidät pelastitte.

— Kiittäkää tuota noin, hän meidät pelasti. Hän kuiskasi minulle:


"Entä ankkurikettingit, eikös niitä pidennetä."

— Signorita Lauricocha! Kiitos teille! huusi kapteeni.

— Muistelin kuulleeni sanottavan laivoista, jotka suuressa


järistyksessä joutuivat torille, etteivät ne olleet laskeneet tarpeeksi
kettinkiä, sanoi Chimb.

Päivän valjettua huomasimme kaikkien laivojen ajautuneen jonkin


verran rantaan päin. Ainoastaan yksi kuunari oli suuremmitta
vammoitta ajautunut rantaan. Mainittakoon, että nousu- ja
pakoveden erotus tällä rannikolla on suurimpia mitä tiedetään,
nimittäin noin neljäkymmentä jalkaa.

Iltapäivällä ankkuroi Callaon satamanselälle saksalainen sotalaiva.


Fred oli jo kaukaa nähnyt Saksan sotalipun mutta luuli laivan
laskevan ankkurinsa etäälle meistä. Laiva ankkuroikin Cuxhavenin
viereen.

— Johan minut perii Saksan saatana! Tuo näyttää ihan tulleen


minua ottamaan, sanoi Fred. Me lohdutimme ystäväämme.

— Kuka sinut täällä tuntee? Ole ihan huoletta, sanoimme.

Cuxhavenin lippu nostettiin tervehdykseksi Saksan sotalaivalle,


kuten asetus määrää. Vähän ajan kuluttua laski sotalaivasta vene
Cuxhavenia kohti. Ennätettiin tuskin saada paraatirappu paikoilleen,
kun vene jo oli sivullamme.

— Onko täällä kapina? kysyi sotalaivan ensimmäinen upseeri.

— On, vastasi kapteeni Franck.

— Kuinka kauan sitä on kestänyt?

— Neljä päivää, vastasi Franck.

— Olemme matkalla San Franciscoon, mutta poikkesimme tänne,


koska ajat ovat kuukausia sitten täällä päin näyttäneet levottomilta.
Eihän meillä ole mitään tekemistä Etelä-Amerikan pikkuvaltioiden
kanssa. Tapelkoot, milloin tahtovat. Mutta meidän velvollisuutemme
on sekaantua leikkiin, jos kansalaisillamme on hätää täällä, sanoi
upseeri.
— Ettekö suvaitse nousta laivaan, sanoi kapteeni.

— Minulla ei ole määräystä siihen. Kai muistatte tehdä


vastavierailun?

— Kyllä tiedän velvollisuuteni, vastasi kapteeni Franck.

Kapteeni Franck kävi sotalaivassa vastavierailulla. Hän kertoi sen


viipyvän Callaossa kapinan päättymiseen saakka. Tämän kuultuaan
sanoi Fred aikovansa hävitä Cuxhavenista heti sopivan tilaisuuden
ilmetessä.

— Ei semmoista tilaisuutta voi tulla. Sotalaivasta pidetään silmällä


kaikkea, mikä tapahtuu tässä laivassa ja koko satamassa. Parasta
on, että ilmoitamme Cuxhavenin kapteenille, miten asianlaita on ja
pyydämme hänen suojelustaan, jos vaara näkyy uhkaavan. Teidän
on pysyteltävä näkymättömissä, sanoi Chimb.

— Kyllä minun on lähdettävä, ehkä jo ensi yönä, kun nousuvesi on


korkeimmillaan. Otan yhden noista korkkipoijuista, ne näkyvät
olevan käyttökuntoisia kaikki. Nousuvesi suuntautuu tuota
metsänrajaa kohti tuolla. Ei tällä rannikolla yleensä ole haikaloja. En
ole ainakaan nähnyt ainoatakaan. On mahdollista, että joudun
surman suuhun pakomatkallani, mutta parempi sekin kuin joutua
isänmaani säälimättömiin rautakouriin. Entä sitten häpeä, jonka isäni
saisi kärsiä, jos asiasta puhuttaisiin sanomalehdissä. Kukapa takaa,
ettei tuo sotalaivan päällikkö isänmaallisessa innossaan pane minua
riippumaan raakapuun nokkaan toisille varoitukseksi, sanoi Fred.

Äänettömyys vallitsi vähän aikaa. Sitten sanoi Mack:


— Kuulin soutumatkalla sotalaivaan, sillä välin kun Cuxhavenin
kapteeni oli vastavierailullaan, että sotalaivalta puuttui useita miehiä.
He olivat karanneet Montevideossa. Kuulin myös, että oli aikomus
matkan varrella ottaa väliaikaisesti uusia miehiä, jos semmoisia oli
saatavissa. Kaksi miestä, jotka laivan ulkopuolella olivat
maalaushommissa, kertoivat tästä toisilleen.

— Jos asiat ovat kuten Mack nyt on kertonut, on parasta, että me


kaikki turvaudumme pelastuspoijuihin ensi puoliyön aikana. Onhan
hyvin mahdollista, että sotalaiva ottaa meidät lainaksi toistaiseksi,
sanoin minä.

— Sitäpä näyttää, ettei täällä ole viipymistä, sanoi Chimb.

— Mitä varten meidän tarvitsee uimalla paeta? Voihan kapteeni


pistää meidät veneellä maihin, sanoi Charley.

— Ei kapteeni siihen suostu, ja jos suostuisikin, niin venematka


yölläkin on vaarallinen. Vene on suuri esine, jonka maavahdit
huomaavat, ja sitä paitsi kuuluu airojen loiske ja kolina, sanoin minä.

Teresia tuli ja vei Chimbin perän puolelle. He kävelivät edes


takaisin ja keskustelivat kiivaasti. Sitten kiersi Teresia kätensä
Chimbin kaulaan ja painoi kasvonsa hänen rintaansa vasten ja rupesi
ääneensä itkemään.

— Jos sinä lähdet pois, ei minulla ole ketään ystävää. Olla laivassa
näkemättä muita kuin miehiä, taivasta, vettä, kaunista ilmaa ja
myrskyä laivan ollessa satamissa, tai keinua aalloilla purjehduksen
aikana. Ei, minä tulen hulluksi.
— Eihän sinun tarvitse olla merillä. Jää kotimaahasi, vastasi
Chimb.
Onhan sinulla kai ystäviä siellä.

— Ei minulla ole ystäviä Euroopassa, eikä minun kotimaanikaan


ole
Euroopassa, se on Peru.

— Vai Peru, sanoi Chimb. Kuinka tuo kapteeni, jota niin rakastat ja
joka näkyy rakastavan sinua, on joutunut sinun isäksesi?

— Asia on yksinkertainen. Isäni oli Valparaisosta kotoisin olevan


chileläisen höyrylaivan perämies. Laiva, joka kuljetti sekä matkustajia
että tavaraa, kulki Valparaison ja Callaon väliä, joka silloin oli vain
Liman satama, eikä mikään kaupunki. Limassa isäni tutustui ja
rakastui äitiini. He menivät naimisiin. Äitini ja minä asuimme ensin
Limassa, mutta sitten muutimme Valparaisoon. Äitini kuoleman
jälkeen — olin silloin kolmen vanha isäni, joka oli saanut kapteenin
paikan saksalaisessa laivassa, vei minut Hampuriin. Siellä kävin
koulua ja kasvoin seitsemäntoista vuotiaaksi. Nyt olen pari vuotta
kuljeskellut isäni kanssa meriä. Isäni ei tule toimeen ilman minua.
Hän on varakkaan puoleinen — tämä laiva muun muassa on hänen
omansa — ja sanoo olevansa onnellinen minun ollessani hänen
luonaan. Hän opettaa minulle meritiedettä loma-aikoina, ja loma-
aikojahan hänellä on runsaasti. Myöskin hän on opettanut minulle
soittoa — viulua ja huilua. Isäni on ottanut laivaansa upseereiksi
etupäässä soitannollisia miehiä. Vieläpä miehistökin rakastaa ja
harrastaa soittoa ja laulua.

— Siinä suhteessahan minä ja neljä toveriani olisimme


mahdottomia tässä laivassa.
— Cuxhaven hoi! kuului laivan sivulta. Sotalaivan vene, joka oli
menossa kaupunkiin, hiljensi sivuuttaessaan meidät.

— Onko laivassanne ketään muita kuin saksalaisia?

— Cuxhavenissa ei ole muita saksalaisia kuin kapteeni ja hänen


tyttärensä, ja miehistöstä on osa karannut, joten Cuxhaven ei ole
purjehduskuntoinen ennen kuin miehistö on täysilukuinen, vastasi
ensimmäinen perämies.

Laivan kapteeni tuli keskikannelle ja sanoi:

— Minä luulen, että sotalaivan päällystö etsii miehiä niiden tilalle,


jotka siitä karkasivat Montevideossa. On mahdollista, että se aikoo
ottaa muutaman minulta, luultavasti jonkun teistä tai teidät kaikki.
Sen vuoksi neuvon teitä lähtemään täältä ennen kuin tuo vene
palaa. Koettakaa piilotella, kunnes kapina on ohi. Ei se monta päivää
enää voi kestää. Kun näette sotalaivan lähteneen, niin tulkaa
takaisin, jos haluatte.

Charley sanoi:

— Kiitos teille, kapteeni. Ehdotuksenne on hyvä. Onhan


mahdollista, ettei rautatien rakennustyötä jatketa tällä kertaa
valtiollisten rettelöiden vuoksi. Kenties sotakin kohta syttyy Perun ja
Chilen välillä. Lähden sen vuoksi mielelläni laivallanne vanhaan
Eurooppaan. En ole merimies, mutta voinhan aina jotakin toimittaa.

— Me toverit lähdemme siis kaikki, minä sanoin.

— Ja luonnollisesti minä myös, sanoi Chimb.

— Et sinä mihinkään saa lähteä, huusi Teresia.


— Eihän teidän ole pakko lähteä. Te voitte tulla meidän
kanssamme ja muuttaa Eurooppaan, sivistyneisiin oloihin, sanoi
kapteeni.

— Paljon on asioita ja seikkoja, jotka minua pidättävät: Isänmaani,


isäni ja äitini, Victoria regia Lauricochan rannalla, — ja entä nämä
toverit, joita rakastan ehkä enemmän kuin mitään muuta
maailmassa! Kuinka he voivat tulla toimeen ilman minua?

— Etkö siis lainkaan välitä minusta, ja minä kun luulin saaneeni


sinusta ikuisen ystävän! Voi Chimb, älä jätä minua, tunnen itseni niin
yksinäiseksi ja juurettomaksi tällä laivalla!

— Olin erehtynyt, kun luulin sinun vain kohteliaisuussyistä


osoittavan ystävyyttä vierasmaalaista kohtaan. Mutta nythän
muistan, ettet olekaan vieras näillä rannoilla. Äitisihän on täkäläisiä.
Toivon, että tapaamme joskus, mutta nyt meidän on erottava.
Jumalan ja esi-isieni Suuren Hengen avulla tulen luoksesi niin pian
kuin pääsen.
V.

Oli jo ilta ja tähdet alkoivat loistaa. Vene oli valmiiksi vedetty laivan
sivuun. Siinä oli kaksi tyhjää vesitynnyriä — meidän piti muka mennä
noutamaan vettä pienen joen suusta, joka sijaitsee metsän rajassa.
Tämä pieni joki saa alkunsa Andeilta ja laskee Tyyneenmereen
vetensä, joka muodostaa kosken parikymmentä syltä rannasta. Se
tulee semmoista vauhtia de los Andeilta, ettei juuri ennätä lämmetä
matkallaan mereen. Vesi on otettava pakoveden aikana, ennen kuin
suolainen merivesi ennättää kosken kohdalle. Pääsimme kunnialla
joen suuhun ja nousimme maihin, jonka jälkeen vene kahden
Cuxhavenin miehistöön kuuluvan miehen soutamana lähti pois,
täyttämättömine vesitynnyreineen. Seisoimme vähän aikaa
äänettöminä. Sitten kuiskasi Chimb:

— Meidän on kuljettava suoraan vasten tuulta. Se on heikko ja


tyyntyy joskus hetkeksi tykkänään. Silloin on parasta seisahtua. Pian
pasaadi taas hengittää ja ohjaa niitä, jotka ovat matkalla kaakkoa
kohti.

Kuljettuamme tunnin ajan pasaadituulen opastamina


tasaisenlaista, harvametsäistä maata, joka rupesi muuttumaan
loivaksi ylämäeksi, viittasi Chimb meidät seisahtumaan.
— Kuulitteko mitään? Minun korviini oli kuuluvinaan raksahdus,
sanoi
Chimb.

Me muut emme olleet kuulleet mitään, jonka vuoksi jatkoimme


kulkuamme.

Jonkin ajan kuluttua Chimb kysyi taas:

— Kuuletteko nyt mitään?

— Nyt kuulemme hiljaista lirinää, sanoimme.

— Oikein olemme kulkeneet. Tuo lirinä kuuluu samasta


vuoripurosta, jonka suulle tulimme veneellä, sanoi Chimb.

Saavuttuamme pienen joen luo rupesimme etsimään paikkaa,


mistä kuivin jaloin pääsisimme yli. Semmoinen löytyikin. Jokipahasen
toisella puolella riippui puun oksalla jotakin.

— Käärmekö tuossa on? kysyi Mack.

— Ei täällä käärmeitä ole, vastasi Chimb.

Riippuva esine oli kaksi toisiinsa kiinnitettyä revolveria ja


patruunavyötä. Täällä siis oli tai oli ollut kapinan kanssa tekemisissä
olevia ihmisiä.

— Eiköhän käännytä ympäri nyt, sanoi Fred.

— Ei se muuta asiaa. Ottakaa nuo vyöt, niistä voi olla meille


hyötyä, sanoi Chimb.
Charley ja Fred panivat vyöt ympärilleen. Kun olimme hiipineet
pienen joen vasenta rantaa ylöspäin ja päässeet kosken ohi, tuli
suvanto, jonka molemmilla puolilla, oli tiheä metsä. Suvanto, jota
eivät tähdet päässeet valaisemaan, näytti pikimustalta. Istahdimme
suurelle kivelle ja katselimme mustaa suvantoa, joka lepäsi
edessämme suuren lätäkön kaltaisena.

— Kai voimme levähtää tässä jonkin ajan? kysyin.

— Eiköhän vain liene viisaampaa jatkaa matkaa vastatuuleen.


Tunnin matkan päässä täältä on hazienda, johon meidän on
pyrittävä. Siellä pääsemme katon alle.

— Mitähän tuolla mustassa vedessä liikkuu? sanoin. Hetken


katseltuamme ja kuunneltuamme olimme varmat siitä, että jotakin
elävää siellä oli ja liikkui.

— Eihän täällä vain alligaattoreita mahda olla? kysyi Mack.

— Ei täällä niitä eläviä ole, sanoivat Chimb ja Charley. — Ennen on


täällä Andien länsipuolellakin ollut boakäärmeitä, mutta niitä ei enää
ole näkynyt vuosikymmeniin. "Metsäkissoja", jaguaareja ja puumoja
näkee vielä joskus.

— Olen katsellut tuota pensasta kohti. Siellä on kaksi olentoa,


jotka liikkuvat ja hengittävät. Katselkaa tarkkaan te, signorita, tuota
mustinta paikkaa kohti, teillähän on paras näkö meistä kaikista,
sanoi Charley.

— Aivan oikein, signor, siinä on kaksi ihmisen päätä, ja ne todella


liikkuvat ja hengittävät, sanoi Chimb.

— Laske, Charley, pari luotia olentoja kohti, sanoi Mack.


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