100% found this document useful (3 votes)
23 views

Kubernetes Programming with Go: Programming Kubernetes Clients and Operators Using Go and the Kubernetes API 1st Edition Philippe Martin All Chapters Instant Download

Martin

Uploaded by

hitiwaamzah14
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (3 votes)
23 views

Kubernetes Programming with Go: Programming Kubernetes Clients and Operators Using Go and the Kubernetes API 1st Edition Philippe Martin All Chapters Instant Download

Martin

Uploaded by

hitiwaamzah14
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 65

Download Full Version ebook - Visit ebookmeta.

com

Kubernetes Programming with Go: Programming


Kubernetes Clients and Operators Using Go and the
Kubernetes API 1st Edition Philippe Martin

https://ebookmeta.com/product/kubernetes-programming-with-
go-programming-kubernetes-clients-and-operators-using-go-
and-the-kubernetes-api-1st-edition-philippe-martin/

OR CLICK HERE

DOWLOAD NOW

Discover More Ebook - Explore Now at ebookmeta.com


Instant digital products (PDF, ePub, MOBI) ready for you
Download now and discover formats that fit your needs...

Start reading on any device today!

Kubernetes Programming with Go: Programming Kubernetes


Clients and Operators Using Go and the Kubernetes API 1st
Edition Philippe Martin
https://ebookmeta.com/product/kubernetes-programming-with-go-
programming-kubernetes-clients-and-operators-using-go-and-the-
kubernetes-api-1st-edition-philippe-martin/
ebookmeta.com

Kubernetes: Preparing for the CKA and CKAD Certifications


Martin

https://ebookmeta.com/product/kubernetes-preparing-for-the-cka-and-
ckad-certifications-martin/

ebookmeta.com

Nonsequential and Distributed Programming with Go.


Christian Maurer

https://ebookmeta.com/product/nonsequential-and-distributed-
programming-with-go-christian-maurer/

ebookmeta.com

Anthology of Student Verse at Pennsylvania Leroy Smith

https://ebookmeta.com/product/anthology-of-student-verse-at-
pennsylvania-leroy-smith/

ebookmeta.com
NCLEX RN For Dummies with Online Practice Tests 2nd
Edition Patrick R Coonan Rhoda L Sommer

https://ebookmeta.com/product/nclex-rn-for-dummies-with-online-
practice-tests-2nd-edition-patrick-r-coonan-rhoda-l-sommer/

ebookmeta.com

Black Decker The Complete Guide to DIY Greenhouses 3rd


Edition Black Decker Editors Of Cool Springs Press Chris
Peterson
https://ebookmeta.com/product/black-decker-the-complete-guide-to-diy-
greenhouses-3rd-edition-black-decker-editors-of-cool-springs-press-
chris-peterson/
ebookmeta.com

Caste Discrimination and Exclusion in Indian Universities


A Critical Reflection 1st Edition N. Sukumar

https://ebookmeta.com/product/caste-discrimination-and-exclusion-in-
indian-universities-a-critical-reflection-1st-edition-n-sukumar/

ebookmeta.com

DK - How to Be Good at Math: The simplest-ever visual


guide, Ages 7-11 Dorling Kindersley

https://ebookmeta.com/product/dk-how-to-be-good-at-math-the-simplest-
ever-visual-guide-ages-7-11-dorling-kindersley-2/

ebookmeta.com

Essential Clinical Procedures 4th Edition Richard Dehn

https://ebookmeta.com/product/essential-clinical-procedures-4th-
edition-richard-dehn/

ebookmeta.com
Press and Politics in Pre-Revolutionary France Jack R.
Censer (Editor)

https://ebookmeta.com/product/press-and-politics-in-pre-revolutionary-
france-jack-r-censer-editor/

ebookmeta.com
Kubernetes Programming
with Go
Programming Kubernetes Clients
and Operators Using
Go and the Kubernetes API

Philippe Martin
Kubernetes Programming with Go: Programming Kubernetes Clients and Operators
Using Go and the Kubernetes API

Philippe Martin
Blanquefort, France

ISBN-13 (pbk): 978-1-4842-9025-5 ISBN-13 (electronic): 978-1-4842-9026-2


https://doi.org/10.1007/978-1-4842-9026-2

Copyright © 2023 by Philippe Martin


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.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Divya Modi
Development Editor: James Markham
Coordinating Editor: Divya Modi
Copy Editor: Kim Burton Wiseman
Cover designed by eStudioCalamar
Cover image designed by Freepik (www.freepik.com)
Distributed to the book trade worldwide by Springer Science+Business Media New York, 1 New York Plaza,
New York, NY 10004. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or
visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is
Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware
corporation.
For information on translations, please e-mail [email protected]; for reprint,
paperback, or audio rights, please e-mail [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to readers
on GitHub via the book's product page, located at https://github.com/Apress/Kubernetes-Programming-
with-Go-by-Philippe-Martin. For more detailed information, please visit http://www.apress.com/
source-code.
Printed on acid-free paper
To Mélina and Elsa, my constant source of truth
Table of Contents
About the Author��������������������������������������������������������������������������������������������������� xiii

About the Technical Reviewers�������������������������������������������������������������������������������xv


Acknowledgments�������������������������������������������������������������������������������������������������xvii

Introduction������������������������������������������������������������������������������������������������������������xix

Chapter 1: Kubernetes API Introduction������������������������������������������������������������������� 1


Kubernetes Platform at a Glance�������������������������������������������������������������������������������������������������� 1
OpenAPI Specification������������������������������������������������������������������������������������������������������������������� 3
Verbs and Kinds���������������������������������������������������������������������������������������������������������������������������� 5
Group-Version-Resource��������������������������������������������������������������������������������������������������������������� 6
Sub-resources������������������������������������������������������������������������������������������������������������������������������ 8
Official API Reference Documentation������������������������������������������������������������������������������������������ 9
The Deployment Documentation������������������������������������������������������������������������������������������� 10
Operations Documentation���������������������������������������������������������������������������������������������������� 12
The Pod Documentation�������������������������������������������������������������������������������������������������������� 14
One-Page Version of the Documentation������������������������������������������������������������������������������� 15
Conclusion���������������������������������������������������������������������������������������������������������������������������������� 16

Chapter 2: Kubernetes API Operations������������������������������������������������������������������� 17


Examining Requests������������������������������������������������������������������������������������������������������������������� 17
Making Requests������������������������������������������������������������������������������������������������������������������������ 18
Using kubectl as a Proxy������������������������������������������������������������������������������������������������������� 18
Creating a Resource�������������������������������������������������������������������������������������������������������������� 19
Getting Information About a Resource����������������������������������������������������������������������������������� 20
Getting the List of Resources������������������������������������������������������������������������������������������������ 20

v
Table of Contents

Filtering the Result of a List�������������������������������������������������������������������������������������������������� 21


Deleting a Resource�������������������������������������������������������������������������������������������������������������� 26
Deleting a Collection of Resources���������������������������������������������������������������������������������������� 26
Updating a Resource������������������������������������������������������������������������������������������������������������� 27
Managing Conflicts When Updating a Resource�������������������������������������������������������������������� 28
Using a Strategic Merge Patch to Update a Resource����������������������������������������������������������� 32
Applying Resources Server-side�������������������������������������������������������������������������������������������� 38
Watching Resources�������������������������������������������������������������������������������������������������������������� 44
Filtering During a Watch Session������������������������������������������������������������������������������������������� 45
Watching After Listing Resources������������������������������������������������������������������������������������������ 45
Restarting a watch Request�������������������������������������������������������������������������������������������������� 46
Allowing Bookmarks to Efficiently Restart a watch Request������������������������������������������������� 47
Paginating Results����������������������������������������������������������������������������������������������������������������� 50
Getting Results in Various Formats��������������������������������������������������������������������������������������������� 52
Getting Results as a Table����������������������������������������������������������������������������������������������������� 52
Using the YAML Format��������������������������������������������������������������������������������������������������������� 54
Using the Protobuf Format���������������������������������������������������������������������������������������������������� 54
Conclusion���������������������������������������������������������������������������������������������������������������������������������� 55

Chapter 3: Working with API Resources in Go�������������������������������������������������������� 57


API Library Sources and Import�������������������������������������������������������������������������������������������������� 57
Content of a Package������������������������������������������������������������������������������������������������������������������ 58
types.go��������������������������������������������������������������������������������������������������������������������������������� 58
register.go������������������������������������������������������������������������������������������������������������������������������ 59
doc.go������������������������������������������������������������������������������������������������������������������������������������ 60
generated.pb.go and generated.proto����������������������������������������������������������������������������������� 60
types_swagger_doc_generated.go��������������������������������������������������������������������������������������� 60
zz_generated.deepcopy.go���������������������������������������������������������������������������������������������������� 61
Specific Content in core/v1��������������������������������������������������������������������������������������������������������� 61
ObjectReference�������������������������������������������������������������������������������������������������������������������� 61
ResourceList�������������������������������������������������������������������������������������������������������������������������� 62
Taint��������������������������������������������������������������������������������������������������������������������������������������� 64

vi
Table of Contents

Toleration������������������������������������������������������������������������������������������������������������������������������� 65
Well-Known Labels���������������������������������������������������������������������������������������������������������������� 66
Writing Kubernetes Resources in Go������������������������������������������������������������������������������������������ 67
Importing the Package���������������������������������������������������������������������������������������������������������� 67
The TypeMeta Fields�������������������������������������������������������������������������������������������������������������� 68
The ObjectMeta Fields����������������������������������������������������������������������������������������������������������� 69
Spec and Status�������������������������������������������������������������������������������������������������������������������� 76
Comparison with Writing YAML Manifests����������������������������������������������������������������������������� 76
A Complete Example������������������������������������������������������������������������������������������������������������������� 78
Conclusion���������������������������������������������������������������������������������������������������������������������������������� 83

Chapter 4: Using Common Types���������������������������������������������������������������������������� 85


Pointers��������������������������������������������������������������������������������������������������������������������������������������� 85
Getting the Reference of a Value������������������������������������������������������������������������������������������� 85
Dereferencing a Pointer��������������������������������������������������������������������������������������������������������� 86
Comparing Two Referenced Values��������������������������������������������������������������������������������������� 86
Quantities������������������������������������������������������������������������������������������������������������������������������������ 87
Parsing a String as Quantity�������������������������������������������������������������������������������������������������� 87
Using an inf.Dec as a Quantity����������������������������������������������������������������������������������������������� 88
Using a Scaled Integer as a Quantity������������������������������������������������������������������������������������� 89
Operations on Quantities������������������������������������������������������������������������������������������������������� 90
IntOrString����������������������������������������������������������������������������������������������������������������������������������� 90
Time�������������������������������������������������������������������������������������������������������������������������������������������� 92
Factory Methods�������������������������������������������������������������������������������������������������������������������� 92
Operations on Time���������������������������������������������������������������������������������������������������������������� 92
Conclusion���������������������������������������������������������������������������������������������������������������������������������� 93

Chapter 5: The API Machinery�������������������������������������������������������������������������������� 95


The Schema Package����������������������������������������������������������������������������������������������������������������� 96
Scheme��������������������������������������������������������������������������������������������������������������������������������������� 97
Initialization��������������������������������������������������������������������������������������������������������������������������� 98
Mapping������������������������������������������������������������������������������������������������������������������������������� 100

vii
Table of Contents

Conversion��������������������������������������������������������������������������������������������������������������������������� 101
Serialization������������������������������������������������������������������������������������������������������������������������� 103
RESTMapper����������������������������������������������������������������������������������������������������������������������������� 105
Kind to Resource����������������������������������������������������������������������������������������������������������������� 106
Resource to Kind����������������������������������������������������������������������������������������������������������������� 107
Finding Resources��������������������������������������������������������������������������������������������������������������� 107
The DefaultRESTMapper Implementation���������������������������������������������������������������������������� 107
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 108

Chapter 6: The Client-go Library��������������������������������������������������������������������������� 109


Connecting to the Cluster��������������������������������������������������������������������������������������������������������� 110
In-cluster Configuration������������������������������������������������������������������������������������������������������� 110
Out-of-Cluster Configuration����������������������������������������������������������������������������������������������� 110
Getting a Clientset��������������������������������������������������������������������������������������������������������������������� 115
Using the Clientset�������������������������������������������������������������������������������������������������������������������� 116
Examining the Requests����������������������������������������������������������������������������������������������������������� 119
Creating a Resource������������������������������������������������������������������������������������������������������������������ 120
Getting Information About a Resource�������������������������������������������������������������������������������������� 122
Getting List of Resources���������������������������������������������������������������������������������������������������������� 123
Filtering the Result of a List������������������������������������������������������������������������������������������������������ 125
Setting LabelSelector Using the Labels Package���������������������������������������������������������������� 125
Setting Fieldselector Using the Fields Package������������������������������������������������������������������ 128
Deleting a Resource������������������������������������������������������������������������������������������������������������������ 130
Deleting a Collection of Resources������������������������������������������������������������������������������������������� 133
Updating a Resource����������������������������������������������������������������������������������������������������������������� 134
Using a Strategic Merge Patch to Update a Resource�������������������������������������������������������������� 135
Applying Resources Server-side with Patch����������������������������������������������������������������������������� 138
Server-side Apply Using Apply Configurations�������������������������������������������������������������������������� 140
Building an ApplyConfiguration from Scratch���������������������������������������������������������������������� 142
Building an ApplyConfiguration from an Existing Resource������������������������������������������������ 143

viii
Table of Contents

Watching Resources����������������������������������������������������������������������������������������������������������������� 145


Errors and Statuses������������������������������������������������������������������������������������������������������������������ 149
Definition of the metav1.Status Structure��������������������������������������������������������������������������� 149
Error Returned by Clientset Operations������������������������������������������������������������������������������� 153
RESTClient�������������������������������������������������������������������������������������������������������������������������������� 154
Building the Request����������������������������������������������������������������������������������������������������������� 154
Executing the Request��������������������������������������������������������������������������������������������������������� 161
Exploiting the Result������������������������������������������������������������������������������������������������������������ 161
Getting Result as a Table����������������������������������������������������������������������������������������������������������� 162
Discovery Client������������������������������������������������������������������������������������������������������������������������ 164
RESTMapper����������������������������������������������������������������������������������������������������������������������������� 165
PriorityRESTMapper������������������������������������������������������������������������������������������������������������ 165
DeferredDiscoveryRESTMapper������������������������������������������������������������������������������������������ 167
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 167

Chapter 7: Testing Applications Using Client-go�������������������������������������������������� 169


Fake Clientset��������������������������������������������������������������������������������������������������������������������������� 170
Checking the Result of the Function������������������������������������������������������������������������������������ 171
Reacting to Actions�������������������������������������������������������������������������������������������������������������� 173
Checking the Actions����������������������������������������������������������������������������������������������������������� 177
Fake REST Client����������������������������������������������������������������������������������������������������������������������� 185
FakeDiscovery Client���������������������������������������������������������������������������������������������������������������� 188
Stubbing the ServerVersion������������������������������������������������������������������������������������������������� 189
Actions��������������������������������������������������������������������������������������������������������������������������������� 190
Mocking Resources������������������������������������������������������������������������������������������������������������� 190
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 191

Chapter 8: Extending Kubernetes API with Custom Resources Definitions���������� 193


Performing Operations in Go����������������������������������������������������������������������������������������������������� 194
The CustomResourceDefinition in Detail����������������������������������������������������������������������������������� 195
Naming the Resource���������������������������������������������������������������������������������������������������������� 196
Definition of the Resource Versions������������������������������������������������������������������������������������� 197
Converting Between Versions���������������������������������������������������������������������������������������������� 198
ix
Table of Contents

Schema of the Resource����������������������������������������������������������������������������������������������������������� 199


Deploying a Custom Resource Definition���������������������������������������������������������������������������������� 201
Additional Printer Columns������������������������������������������������������������������������������������������������������� 204
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 207

Chapter 9: Working with Custom Resources�������������������������������������������������������� 209


Generating a Clientset��������������������������������������������������������������������������������������������������������������� 209
Using deepcopy-gen������������������������������������������������������������������������������������������������������������ 211
Using client-gen������������������������������������������������������������������������������������������������������������������ 213
Using the Generated Clientset��������������������������������������������������������������������������������������������� 216
Using the Generated fake Clientset������������������������������������������������������������������������������������� 217
Using the Unstructured Package and Dynamic Client��������������������������������������������������������������� 217
The Unstructured Type��������������������������������������������������������������������������������������������������������� 217
The UnstructuredList Type��������������������������������������������������������������������������������������������������� 221
Converting Between Typed and Unstructured Objects�������������������������������������������������������� 223
The Dynamic Client�������������������������������������������������������������������������������������������������������������� 223
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 229

Chapter 10: Writing Operators withthe Controller-­Runtime Library��������������������� 231


The Manager����������������������������������������������������������������������������������������������������������������������������� 232
The Controller��������������������������������������������������������������������������������������������������������������������������� 235
Creating a Controller����������������������������������������������������������������������������������������������������������� 236
Watching Resources������������������������������������������������������������������������������������������������������������ 237
A First Example������������������������������������������������������������������������������������������������������������������� 241
Using the Controller Builder������������������������������������������������������������������������������������������������ 244
A Second Example Using the ControllerBuilder������������������������������������������������������������������� 245
Injecting Manager Resources into the Reconciler��������������������������������������������������������������� 247
Using the Client������������������������������������������������������������������������������������������������������������������������� 250
Getting Information About a Resource��������������������������������������������������������������������������������� 250
Listing Resources���������������������������������������������������������������������������������������������������������������� 251
Creating a Resource������������������������������������������������������������������������������������������������������������ 254
Deleting a Resource������������������������������������������������������������������������������������������������������������ 254

x
Table of Contents

Deleting a Collection of Resources�������������������������������������������������������������������������������������� 255


Updating a Resource����������������������������������������������������������������������������������������������������������� 256
Patching a Resource������������������������������������������������������������������������������������������������������������ 256
Updating the Status of a Resource�������������������������������������������������������������������������������������� 259
Patching the Status of a Resource�������������������������������������������������������������������������������������� 260
Logging������������������������������������������������������������������������������������������������������������������������������������� 261
Verbosity������������������������������������������������������������������������������������������������������������������������������ 262
Predefined Values���������������������������������������������������������������������������������������������������������������� 262
Logger Name����������������������������������������������������������������������������������������������������������������������� 262
Getting the Logger from Context����������������������������������������������������������������������������������������� 263
Events��������������������������������������������������������������������������������������������������������������������������������������� 263
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 265

Chapter 11: Writing the Reconcile Loop��������������������������������������������������������������� 267


Writing the Reconcile Function������������������������������������������������������������������������������������������������� 268
Checking Whether the Resource Exists������������������������������������������������������������������������������� 268
Implementing the Reconciled Resource������������������������������������������������������������������������������ 268
Simple Implementation Example����������������������������������������������������������������������������������������� 270
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 275

Chapter 12: Testing the Reconcile Loop��������������������������������������������������������������� 277


The envtest Package����������������������������������������������������������������������������������������������������������������� 277
Installing envtest Binaries��������������������������������������������������������������������������������������������������� 277
Using envtest����������������������������������������������������������������������������������������������������������������������� 278
Defining a ginkgo Suite������������������������������������������������������������������������������������������������������������� 279
Writing the Tests����������������������������������������������������������������������������������������������������������������������� 283
Test 1����������������������������������������������������������������������������������������������������������������������������������� 284
Test 2����������������������������������������������������������������������������������������������������������������������������������� 285
Test 3����������������������������������������������������������������������������������������������������������������������������������� 285
Test 4����������������������������������������������������������������������������������������������������������������������������������� 285
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 290

xi
Table of Contents

Chapter 13: Creating an Operator with Kubebuilder�������������������������������������������� 291


Installing Kubebuilder��������������������������������������������������������������������������������������������������������������� 291
Creating a Project��������������������������������������������������������������������������������������������������������������������� 291
Adding a Custom Resource to the Project�������������������������������������������������������������������������������� 293
Building and Deploying Manifests�������������������������������������������������������������������������������������������� 295
Running the Manager Locally��������������������������������������������������������������������������������������������������� 295
Personalizing the Custom Resource����������������������������������������������������������������������������������������� 296
Editing the Go Structures���������������������������������������������������������������������������������������������������� 297
Enabling the Status Subresource���������������������������������������������������������������������������������������� 297
Defining Printer Columns����������������������������������������������������������������������������������������������������� 297
Regenerating the Files�������������������������������������������������������������������������������������������������������� 298
Implementing the Reconcile Function�������������������������������������������������������������������������������������� 299
Adding RBAC Annotations��������������������������������������������������������������������������������������������������������� 299
Deploying the Operator on the Cluster�������������������������������������������������������������������������������������� 300
Creating a New Version of the Resource����������������������������������������������������������������������������������� 301
Defining a New Version������������������������������������������������������������������������������������������������������� 302
Implementing Hub and Convertible������������������������������������������������������������������������������������� 303
Setting Up the webhook������������������������������������������������������������������������������������������������������ 305
Updating kustomization Files���������������������������������������������������������������������������������������������� 306
Using Various Versions�������������������������������������������������������������������������������������������������������� 306
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 308

Index��������������������������������������������������������������������������������������������������������������������� 309

xii
About the Author
Philippe Martin has been working with Kubernetes for
five years, first by creating an Operator to deploy video
CDNs into the cloud, later helping companies deploy their
applications into Kubernetes, then writing a Client to help
developers work in a Kubernetes environment. Philippe
has passed the CKAD, CKA, and CKS certifications. He has
extensive experience with distributed systems and open-
source software: he started his career 20 years ago creating
thin clients based on the Linux kernel and open-­source
components. He is currently working at Red Hat on the
Development Tools team.
Philippe has been active in the development of Kubernetes, especially its
documentation, and participates in the translation of the official documentation into
French, has edited two reference books about the Kubernetes API and kubectl, and is
responsible for the French translation of the Kubernetes Dashboard. He participated in
Google Season of Docs to create the new Kubernetes API Reference section of the official
documentation and is maintaining it.

xiii
About the Technical Reviewers
Bartosz Majsak writes code for fun and profit while proudly
wearing a red fedora (also known as the Red Hat). He has
been long-time open-source contributor and Java developer
turned into Golang aficionado. Bartosz is overly enthusiastic
about coffee, open source, and speaking at conferences,
not necessarily in that order. One thing that perhaps proves
he is not a total geek is his addiction to alpine skiing (and
running).

Prasanth is a Blockchain Certified Professional, Professional


Scrum Master, and Microsoft Certified Trainer who is
passionate about helping others learn how to use and gain
benefits from the latest technologies. He is a thought leader
and practitioner in Blockchain, Cloud, and Scrum. He also
handles the Agile Methodology, Cloud, and Blockchain
technology community initiatives within TransUnion
through coaching, mentoring, and grooming techniques.
Prasanth is an adjunct professor and a technical speaker.
He was selected as a speaker at the China International
Industry Big Data Expo 2018 by the Chinese government and also was invited to the
International Blockchain Council by the Government of Telangana and Goa. In addition,
he received accolades from the Chinese government for his presentation at China
International Industry Big Data Expo 2018. Prasanth has published his Patent, entitled
“Digital Educational Certificate Management System Using IPFS-Based Blockchain.”
To date, he has interacted extensively, reaching more than 50,000 students,
mostly within the technical domain. Prasanth is a working group member of the
CryptoCurrency Certification Consortium, the Scrum Alliance, the Scrum Organization,
and the International Institute of Business Analysis.

xv
Acknowledgments
I would like to thank the whole Anevia “CDN” team who started working with me on
Kubernetes back in 2018: David, Ansou, Hossam, Yassine, Étienne, Jason, and Michaël.
Special thanks to Damien Lucas for initiating this project and for having trusted us with
this challenge.
My discovery of Kubernetes has been much easier and pleasant thanks to the TGIK
channel and its numerous episodes, hosted by Joe Beda, Kris Nova, and many others.
Plus, thanks to all the Kubernetes community for such a great ecosystem!

xvii
Introduction
Back in 2017, I was working for a company building video streaming software. At the end
of that year, a small team, including me, got assigned a new job to work on deploying
the Video CDN developed by the company on Kubernetes. We decided to explore the
concept of Custom Resources and Operators to deploy this CDN.
The current Kubernetes release was 1.9, the concept of Custom Resource Definition
had just been released in 1.7, and the sample-controller repository was the only
documentation we knew of to help build an Operator. The Kubernetes ecosystem,
being especially lively, had tools appearing in the following months, specifically the
Kubebuilder SDK. Thus, our project was launched.
From that moment on, I spent numerous days exploring how to build Operators and
other programs interacting with the Kubernetes API. But the damage was done: I had
started to learn Kubernetes programming from specific to general, and it took me a long
time to fully understand the innards of the Kubernetes API.
I have written this book in the hope that it can teach new Kubernetes developers how
to program, from general to specific, with the Kubernetes API in Go.

Chapters at a Glance
The target reader for this book has some experience working with REST APIs, accessing
them either by HTTP or using clients for specific languages; and has some knowledge of
the Kubernetes platform, essentially as a user—for example, some experience deploying
such APIs or frontend applications with the help of YAML manifests.

• Chapter 1 of the book explores the Kubernetes API and how it


implements the principles of REST. It especially focuses on the
Group-Version-Resource organization and the Kind concept
proposed by the API.
• Chapter 2 continues by covering the operations proposed by the API
and the details of each operation, using the HTTP protocol.

xix
Introduction

• Chapters 3 to 5 describe the common and “low-level” Go libraries to


work with the Kubernetes API: the API and API Machinery Libraries.

• Chapters 6 and 7 cover the Client-go Library—the high-level library


to work with the Kubernetes API in Go—and how to unit test code
using this library.

At this point in the book, the reader should be comfortable with building Go
applications working with native resources of the Kubernetes API.

• Chapters 8 and 9 introduce the concept of Custom Resources and


how to work with them in Go.

• Chapters 10 to 12 cover the implementation of Kubernetes Operators


using the controller-runtime library.

• Chapter 13 explores the Kubebuilder SDK, a tool to help develop and


deploy Kubernetes Operators.

By the end of the book, the reader should be able to start building Kubernetes
operators in Go and have a very good understanding of what happens behind the scenes.

xx
CHAPTER 1

Kubernetes API
Introduction
Kubernetes is a platform to orchestrate containers operating in the declarative mode.
There are one-thousand-and-one ways to describe how the Kubernetes platform is
constructed. This book focuses on programming with the platform.
The entry point of the Kubernetes platform is the API. This chapter explores the
Kubernetes architecture by highlighting the central role of the Kubernetes API. It then
focuses on the HTTP REST nature of the Kubernetes API, and on the extensions added to
organize the many resources managed by it.
Finally, you will learn how to navigate the reference documentation effectively to be
able to extract the maximum quantity of useful information daily.

Kubernetes Platform at a Glance


On one side of the chain, the user declares the high-level resources to build applications
to deploy: Deployments, Ingresses, and so on.
In the middle, controllers are activated to transform these resources into low-level
resources (Pods), and the scheduler distributes these resources into nodes. On the other
side of the chain, the node agents deploy the low-level resources onto nodes.
The main elements of the Kubernetes platform (commonly called the control-plane)
are highlighted in Figure 1-1 and described in the following:

1. The API server – this is the central point on the control-plane; the
user and the various pieces of the control-plane contact this API to
create, get, delete, update, and watch resources.

2. The etcd database – this is only accessible by the API Server, is


used to persist the data relative to resources.

1
© Philippe Martin 2023
P. Martin, Kubernetes Programming with Go, https://doi.org/10.1007/978-1-4842-9026-2_1
Chapter 1 Kubernetes API Introduction

3. The Controller manager – this runs the controllers that transform


high-level resources declared by the user into low-level resources
to be deployed on nodes. The controllers are connected to the API
Server, watching for high-level resources and creating, deleting,
and updating low-level resources to satisfy the specifications
declared in high-level resources.

4. Scheduler – this distributes the low-level resources on the various


nodes. The Scheduler is connected to the API Server to watch for
unaffected resources and connect them to nodes.

5. Kubelet – this is an agent running on all nodes of the cluster,


and each agent manages the workloads affected to its node. The
kubelet is connected to the API Server to watch for Pods resources
affected to its node and to deploy the associated containers using
the local container runtime.

6. Kube proxy – this is an agent running on all nodes of the cluster,


and each agent manages the network configurations affected to
its node. The kube proxy is connected to the API Server to watch
for Service resources and to configure associated network rules on
its node.

2
Chapter 1 Kubernetes API Introduction

etcd
Kubectl
---

Control-plane
cre
at watch
de e set
up lete,
d
Controllers
wa ate
tch
API Server crea
te
te
dele te
a
upd
tch
wa

wa ate
tch
up
d
Kubelet
watch

Scheduler
no Kube-proxy
de
s

Figure 1-1. The architecture of Kubernetes

O
 penAPI Specification
The Kubernetes API is an HTTP REST API. The Kubernetes team provides a specification
for this API in the OpenAPI format, either in v2 format at https://github.com/
kubernetes/kubernetes/tree/master/api/openapi-spec or in Kubernetes v1.24,
in v3 format, at https://github.com/kubernetes/kubernetes/tree/master/api/
openapi-spec/v3.
These specifications also are accessible from the API Server at these paths:
/openapi/v2 and /openapi/v3.
An OpenAPI specification is made up of various parts and, among these, are a list of
paths and a list of definitions. The paths are the URLs you use to request this API, and
for each path, the specification gives the distinct operations such as get, delete, or post.
Then for each operation, the specification indicates what are the parameters and body
format for the request, and what are the possible response codes and associated body
format for the response.

3
Chapter 1 Kubernetes API Introduction

The parameters and bodies for requests and responses can be either simple types
or, more generally, structures containing data. The list of definitions includes data
structures that help build the parameters and bodies for the operations’ requests and
responses.
Figure 1-2 is a simplified view of a specification for a User API. This API can accept
two different paths: /user/{userId} and /user. The first path, /user/{userId}, can accept
two operations, get and delete, respectively, to receive information about a specific user,
given its user ID; and to delete information about a specific user, given its user ID. The
second path, /user, can accept a single operation, post, to add a new user, given its
information.
In this API, a definition of a structure User is given, describing the information for a
user: its ID, first name, and last name. This data structure is used in the response body of
the get operation on the first path, and in the request body of the post operation on the
second path.

4
Chapter 1 Kubernetes API Introduction

SDWKV
XVHU^XVHU,G`
JHW
SDUDPHWHUV
XVHU,GLQWHJHU
UHTXHVW%RG\ HPSW\
UHVSRQVHV

8VHU
GHOHWH
SDUDPHWHUV
XVHU,GLQWHJHU
UHTXHVW%RG\ HPSW\
UHVSRQVHV
 HPSW\
XVHU
SRVW
SDUDPHWHUV HPSW\
UHTXHVW%RG\8VHU
UHVSRQVHV

8VHU
GHILQLWLRQV
8VHU
,'LQWHJHU
)LUVW1DPHVWULQJ
/DVW1DPHVWULQJ

Figure 1-2. A simplified user API specification

V
 erbs and Kinds
The Kubernetes API adds two concepts to this specification: the Kubernetes API Verbs
and the Kubernetes Kinds.

5
Chapter 1 Kubernetes API Introduction

The Kubernetes API Verbs are mapped directly to the operations in the OpenAPI
specification. The defined verbs are get, create, update, patch, delete, list, watch, and
deletecollection. The correspondence with the HTTP verbs can be found in Table 1-1.

Table 1-1. Correspondence Between


Kubernetes API Verbs and HTTP Verbs
Kubernetes API Verb HTTP Verb

get GET
create POST
update PUT
patch PATCH
delete DELETE
list GET
watch GET
deletecollection DELETE

The Kubernetes Kinds are a subset of the definitions in the OpenAPI specification.
When requests are made to the Kubernetes API, data structures are exchanged through
the bodies of requests and responses. These structures share common fields, apiVersion
and kind, to help the participants of the request recognize these structures.
If you wanted to make your User API manage this Kind concept, the User structure
would contain two additional fields, apiVersion and kind—for example, with values v1
and User. To determine whether a definition in the Kubernetes OpenAPI specification
is a Kubernetes Kind, you can look at the x-kubernetes-group-version-kind field of the
definition. If this field is defined, the definition is a kind, and it gives you the values of the
apiVersion and kind fields.

Group-Version-Resource
The Kubernetes API is a REST API, and as a result of that it manages Resources, and the
paths to manage these resources follow the REST naming conventions—that is, by using
a plural name to identify a resource and by grouping these resources.

6
Chapter 1 Kubernetes API Introduction

Because the Kubernetes API manages hundreds of resources, they are grouped
together, and because the API evolves, the resources are versioned. For these reasons,
each resource belongs to a given Group and Version, and each resource is uniquely
identified by a Group-Version-Resource, commonly known as GVR.
To find the various resources in the Kubernetes API, you can browse the OpenAPI
specification to extract the distinct paths. Legacy resources (e.g., pods or nodes) will
have been introduced early in the Kubernetes API and all belong to the group core and
the version v1.
The paths to manage legacy resources cluster-wide follow the format /api/
v1/<plural_resource_name>—for example, /api/v1/nodes to manage nodes. Note
that the core group is not represented in the path. To manage resources in a given
namespace, the path format is /api/v1/namespaces/<namespace_name>/<plural_
resource_name>—for example, /api/v1/namespaces/default/pods to manage pods in
the default namespace.
Newer resources are accessible through paths following the format
/apis/<group>/<version>/<plural_resource_name> or /apis/<group>/<version>/
namespaces/<namespace_name>/<plural_resource_name>.
To summarize, the formats of the various paths to access resources are:

• /api/v1/<plural_name> – to access legacy non-namespaced


resources

Ex: /api/v1/nodes to access non-namespaced nodes resources

or

To access legacy namespaced resources cluster-wide

Ex: /api/v1/pods to access pods across all namespaces

• /api/v1/namespaces/<ns>/<plural_name> – to access legacy


namespaced resources in a specific namespace

Ex: /api/v1/namespaces/default/pods to access pods in the default


namespace

• /apis/<group>/<version>/<plural_name> – to access non-­


namespaced resources in specific group and version

Ex: /apis/storage.k8s.io/v1/storageclasses to access non-­


namespaced storageclasses (group storage.k8s.io, version v1)

7
Chapter 1 Kubernetes API Introduction

or

To access namespaced resources cluster-wide

Ex: /apis/apps/v1/deployments to access deployments across all


namespaces

• /apis/<group>/<version>/namespaces/<ns>/<plural_name> – to
access namespaced resources in a specific namespace

Ex: /apis/apps/v1/namespaces/default/deployments to access


deployments (group apps, version v1) in the default namespace

Sub-resources
Following the REST API convention, the resources can have sub-resources. A sub-­
resource is a resource that belongs to another and can be accessed by specifying its
name after the name of the resource, as follows:

• /api/v1/<plural>/<res-name>/<sub-resource>
Ex: /api/v1/nodes/node1/status

• /api/v1/namespaces/<ns>/<plural>/<res-name>/<sub-resource>
Ex: /api/v1/namespaces/ns1/pods/pod1/status

• /apis/<group>/<version>/<plural>/<res-name>/<sub-resource>
Ex: /apis/storage.k8s.io/v1/volumeattachments/volatt1/status

• /apis/<grp>/<v>/namespaces/<ns>/<plural>/<name>/<sub-res>
Ex: /apis/apps/v1/namespaces/ns1/deployments/dep1/status

Most Kubernetes resources have a status sub-resource. You can see, when writing
operators, that the operator needs to update the status sub-resource to be able to
indicate the state of this resource observed by the operator. The operations that can
be executed in the status sub-resource are get, patch, and update. The Pod has more
sub-resources, including attach, binding, eviction, exec, log, portforward, and proxy.
These sub-resources are useful for getting information about a specific running pod, or
executing some specific operation on a running pod, and so on.

8
Chapter 1 Kubernetes API Introduction

The resources that can Scale (i.e., deployments, replicasets, etc.) have a scale sub-­
resource. The operations that can be executed in the scale sub-resource are get, patch,
and update.

Official API Reference Documentation


The official reference documentation of the API can be found at https://kubernetes.
io/docs/reference/kubernetes-api/. The resources managed by the API are first
grouped together by category (i.e., workloads, storage, etc.), and for each category, you
can obtain a list of resource names with a short description (Figure 1-3).

Figure 1-3. The Kubernetes resources grouped by category

Note that these categories are not part of the Kubernetes API definition but are used
in this website to help inexperienced users find their way into the multitude of available
resources.

9
Chapter 1 Kubernetes API Introduction

To be precise, the name displayed is not the resource name in the REST sense, but
the associated principal kind, as shown in Figure 1-4. For example, when managing
Pods, the resource name used in the REST paths is pods (i.e., lowercase and plural), and
the definition used to exchange information about Pods during HTTP requests is named
Pod (i.e., uppercase and singular). Note that other kinds can be associated with the same
resource. In the example in this chapter, the PodList kind (used to exchange information
about Lists of Pods) also exists.

Figure 1-4. The resources for a specific category, with a short description

The Deployment Documentation


Let’s explore the reference page for the Deployment available at this address:
https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/
deployment-v1/. The title of the page, Deployment, is the principal kind associated with
the deployments resource shown in Figure 1-5.

10
Chapter 1 Kubernetes API Introduction

Figure 1-5. The Deployment documentation page

The apiVersion indicated in the header can help you write a YAML manifest for a
Deployment resource because you need to specify, for each resource in a Kubernetes
manifest, the apiVersion and kind.
In this case, you know the manifest for a deployment will start with the following:

apiVersion: apps/v1
kind: Deployment

The next header line indicates the import to use when writing Go code. In Chapter 3,
you will see how to use this import when describing resources in Go.

After the header, a list of structure definitions is described, also accessible from the
table of contents for the Deployment documentation page in Figure 1-6. The first one is
the principal kind of the resource, optionally followed by structure definitions that are
used in fields of the first kind.

11
Chapter 1 Kubernetes API Introduction

Figure 1-6. Table of contents for the Deployment documentation page

For example, the Deployment kind contains a spec field, of type DeploymentSpec,
which is described later. Note that DeploymentSpec is not a structure directly
exchanged during HTTP requests, and for that, it is not a kind and does not contain kind
or apiVersion fields.
Following the principal kind, and its associated definitions, other kinds associated
with the resource are displayed. In this case, the DeploymentList kind.

Operations Documentation
The next subject in the API Documentation for a resource is the list of possible
operations on this resource or its sub-resources, also accessible from the table of
contents page (see Figure 1-6). By examining the details for the create operation to
Create a Deployment, as shown in Figure 1-7, you can see the HTTP Request verb and
path to use, the parameters to pass during the request, and the possible responses. The
HTTP verb to use for the request is POST and the path is ­/apis/apps/v1/namespaces/
{namespace}/deployments.

12
Chapter 1 Kubernetes API Introduction

Figure 1-7. Details for a “create” Deployment operation

The {namespace} part of the path indicates a path parameter, which is to be


replaced by the name of the namespace on which you want to create the deployment.
You can specify the query parameters: dryRun, fieldManager, fieldValidation, and
pretty. These parameters will follow the path with the format path?dryRun=All.
The body of the request must be a Deployment kind. When using kubectl, you are
writing Kubernetes Manifests that contain this body. In Chapter 3, you will see how to
build the body in Go. The possible HTTP codes for the responses are: 200, 201, 202, and
401; and for the 2xx codes, the response body will contain a Deployment kind.

13
Discovering Diverse Content Through
Random Scribd Documents
de una felicidad plena, redonda y definitiva. Sino fuera por el jactancioso
ruido del tren, oiríanse, de seguro, las voces de su canto. No se concebía a
aquel hombre en aquella hora sino cantando.
Reía entre tanto la naturaleza, y cada nimio detalle del paisaje se revestía
de una íntima belleza. En el paisaje aquel, tan simple y sobrio, faltaban los
elementos teatrales y decorativos. Pero había un amable encanto en la
hierba matizada de rocío, en la lechuza que se posaba sobre un poste y abría
sus curiosas y atónitas pupilas circulares, en las ovejas que pastaban, en el
desbande de las aves azoradas, en la cómica expectación de los novillos
ante el paso ruidoso del tren. Y, sobre todo, en la luz purísima que inundaba
la llanura, aquella infinita llanura que se abría delante de la imaginación
como un concepto casi metafísico de la libertad y de lo inconmensurable.
Y yo pensé: ¿Somos más felices los hombres porque amontonemos
mayor número de útiles, de necesidades y de ideas? Aquel rancho[22]
perdido en la llanura, aquellos dos sauces, el fogón encendido, la mujer que
se queda amamantando a su criatura y el hombre que sale a cabalgar serena
y noblemente, ¿no representaban la suma de las cosas y de las emociones
que requiere un hombre para sentirse bien dentro del universo y cara a la
vida? En aquella cabaña se habían reducido las necesidades hasta el
mínimo. Siendo tan pocas las exigencias, el alma, en aquella parquedad de
apetitos, debía pensar que el mundo era aún demasiado pródigo. Era la
antítesis de la gran metrópoli, de la ciudad insaciable y codiciosa, de la urbe
consumida por las pasiones. La ciudad no se satisfacía nunca. Anhelaba
siempre más, nuevas formas de placer y de molicie. Las grandes fábricas
gemían continuamente para producir los útiles, tan caros a la civilización;
los hombres de ciencia alargaban sus vigilias para sorprender una nueva
invención; y corrían los barcos y los trenes, acarreando cosas aptas para la
molicie del hombre, y las calles se llenaban de fiebre, los Bancos
multiplicaban sus negocios, el mundo entero vibraba al conjuro del
universal anhelo. Todo para que unos hombres pudieran usar cosas
agradables, y todo para que la vida se llenase de complicación. Lujo,
vanidad, automóviles, timbres eléctricos, ascensores, teléfonos, bebidas
heladas, salsas, especies, vinos espumantes, vestidos de seda, sombreros
increíbles. Para satisfacer estas necesidades artificiosas, el mundo llenábase
de inquietudes, estallaban las guerras, morían los miserables en los
rincones.
En ese rancho perdido en mitad de la llanura ¿qué faltaba? La vida no
reclamaba sino tres o cuatro casos simples: un pedazo de carne asada, una
infusión de “mate”, y, como lujo, una galleta dura. Quizá un poco de tabaco
para las horas de reposo. Y en los días de fiesta, un trago de ginebra. Para
dormir, el sagrado suelo. Y en las noches tibias, tener como techumbre el
cielo, empavesado de estrellas.
He ahí una razón fundamental: la vida conquistada a bajo precio. Pero la
otra razón, la que se apoya sobre los intereses eternos, colectivos,
universales, arguye que ese plan de vida es ruinoso, y que al simplificar las
necesidades, reduciendo el radio de nuestros deseos, la civilización corre
apuro de malograrse. La civilización es un algo supremo, inasequible,
imponderable como el mismo Dios. Todos venimos a ofrecernos como
servidores de ese fetiche insaciable, y sudamos, padecemos, morimos entre
estertores de codicia, de vanidad o de ambición, a la mayor gloria del
progreso. Se nos dice que es humillante desertar de nuestro puesto. Y
efectivamente cumplimos con nuestro deber.
Por mi parte, yo siento en muchas ocasiones una fuerte intención de
desertar. Siempre que me sitúo enfrente de la naturaleza libre, ingenua y
pictórica, me asalta el mismo prurito de renunciar a mi corteza urbana,
quitarme el uniforme de civilizado, traicionar a la obra del progreso y
convertirme en un hombre sencillo.
He pensado seriamente en llegar a poder vivir así, como aquel paisano
que a lomo de su potro tordillo salía cantando de mañana por lo ancho de la
llanura. Renunciar a los numerosos detalles de la civilización, despreciar la
vestidura del placer, la apariencia sonora de la dicha, a cambio de la
verdadera felicidad. Reconciliarse con la salud, auténtica madre de la
alegría. Ejercitar las funciones corporales con una segura amplitud. Sentir la
plena conciencia de la normalidad del ser. Dormir sin achaques, de un largo
y robusto tirón. Cabalgar, vencer las dificultades que se oponen al músculo,
sudar, beber agua sana a grandes tragos. Respirar el viento sin temor, y
agradecerlo más aún cuanto más frío. Ofrecerse al sol sin veladuras ni
encogimientos. Recibir el golpe de la lluvia como una caricia. Curtirse la
piel, tensa como un pandero. Ver acostarse el sol, sin miedo al mañana.
Levantarse con el alba y agradecer con todas las fuerzas del cándido
espíritu la gracia de poder vivir un nuevo día...
CA P Í T UL O V

El Amor y la Queja

P OR las páginas del Martín Fierro corre constantemente un aura de queja


y de reproche melancólico, y esto da al poema cierta monotonía, como
de cancionero andaluz. Entre el gaucho y el andaluz existen
coincidencias de tono y de sentimientos tan marcadas, que otra vez me veré
inclinado a insistir sobre el paralelismo de dos pueblos que el Atlántico
separa, pero que el origen y el concepto de la vida mantienen siempre
unidos.
La queja del gaucho Martín Fierro va dirigida en dos direcciones: el
abuso social y los males del amor. En el fondo, sin duda, lo que el poeta
Hernández se propuso fué una patética e indignada recusación de los
móviles ciudadanos, y del plan abusivo de las ciudades costeñas, como
Buenos Aires, que henchidas de elementos inmigrantes, poseídas de un
torvo espíritu de presa y con una despiadada prisa por el éxito y por la
civilización a ultranza, arremetían contra el gaucho, lo hallaban reacio, lo
oprimían y lo expulsaban, arbitraria y brutalmente, de la tierra y del
usufructo del país. De modo que el poema del Martín Fierro viene a ser una
protesta de la tradición, del argentinismo, de la argentinidad histórica, y en
efecto marca la línea que divide las dos épocas: una puramente criolla, con
sus luchas políticas, sus violencias y también su generosidad romántica e
idealista, su apasionamiento noble; la otra época corresponde al moderno
contenido social, en que se ha levantado una nación ágil y ambiciosa, llena
de arrivismos y de irreverencias, confuso vientre donde pululan todos los
extranjerismos.
Esta defensa del gaucho oprimido y esquilmado forma el motivo del
poema. Pero la queja hubiera saltado de cualquier modo, porque la raíz del
criollismo pampeano consiste en un acatamiento a la ley de fatalidad, y en
una profunda e instintiva comprensión del duro e insuperable destino. El
criollo es fatalista como un andaluz; la parte de semitismo que heredara de
sus abuelos, se ve todavía corroborada por el fatalismo de las razas indias.
Sobre la negrura de su fatalismo, igual que en el alma andaluza; el criollo
vierte, a manera de relámpagos, sus chistes y donosidades, su graciosa
socarronería.
Las estrofas del Martín Fierro, por tanto, recuerdan directamente las
coplas andaluzas de la malagueña. Al comenzar un episodio, en cualquier
intervalo de su narración, Martín Fierro lanza al aire libre de la llanura
solitaria su queja, que es como una reconvención al destino.

Triste suena mi guitarra,


y el asunto lo requiere;
ninguno alegrías espere
sino sentidos lamentos,
de aquel que en duros tormentos
nace, crece, vive y muere.

Los últimos versos de esta estrofa recuerdan inmediatamente a nuestro


Segismundo de “La vida es sueño”. En el poema de Hernández hay otras
varias referencias a libros españoles, que iremos anotando después; el
Quijote está patente en el Martín Fierro, y la obsesión de Espronceda
obsérvase igualmente a lo largo del poema criollo. Los consejos que da el
viejo Vizcacha a un hijo de Fierro, son eco demasiado patente de las
advertencias que el presidiario hace al héroe de El Diablo Mundo.
La queja del gaucho se parece a la del andaluz; pero si en la copla
andaluza palpita frecuentemente la indignación, la violencia o el arrebato
pasional, en la estrofa criolla vaga un no sé qué de resignado y suave. Rara
vez suena la copla criolla a maldición y a rebeldía, como en el canto
andaluz; el gaucho gime con un tono más pasivo, más rendido y
caballeresco; hace, frente al desdén de su dama, no como el enamorado
andaluz, sino como el enamorado gallego o el galán provenzal.
Yo me atrevo a reproducir, dándole un valor totalmente representativo
del carácter sentimental criollo, esta vidalita, muy popular en las tierras del
Plata:
Palomita blanca,
vidalitá,
la que yo crié;
salió tan ingrata,
vidalitá,
que voló y se fué...

Toma aquí el sentimiento de un pueblo la expresión más resignada, triste


y vagorosa. Apenas si el enamorado osa protestar. Es como si admitiera la
ley del destino que convierte a la mujer en cosa deseable, frágil, bella,
fácilmente desvanecible. Admite la fatalidad, y como buen fatalista no
incurre en la inútil propensión a la ira y los desesperados ultrajes.
Se siente, pues, el gaucho obligado a una actitud de compostura frente al
desvío inevitable de la mujer. Y toma la postura del lamento según la buena
tradición romántica y caballeresca del galán desgraciado; se refugia, pues,
en la queja transcendental, en el suspiro y en el culto ácido de la ausencia.
La ausencia, como tema de erotismo desgraciado, llena el fondo del
cancionero popular argentino.
La copla andaluza exclama:

Entre Córdoba y Lucena


hay una laguna clara
donde lloraba mis penas
cuando de tí me acordaba.

Pero aun aquí resalta o se entrevé la esperanza de recuperar el amor


malogrado, o se presiente la secreta ira del amador que podrá acaso alguna
vez ejercitar su derecho a la venganza. El defraudado galán criollo se
contenta con gemir:

Palomita blanca,
remonta tu vuelo,
y al bien que yo adoro
dile que me muero...
También Martín Fierro colabora en esta propensión a la queja dulce y al
dolor de la ausencia. Azuzado por la justicia, pobre y errante, necesita poner
su memoria en la dama de sus pensamientos y canta:

Es triste dejar sus pagos


y largarse a tierra ajena,
llevándose el alma llena
de tormentos y dolores;
mas nos llevan los rigores
como el pampero[23] a la arena.

Cuántas veces al cruzar


en esa inmensa llanura,
al verse en tal desventura
y tan lejos de los suyos,
se tira uno entre los yuyos[24]
a llorar con amargura.

En la orilla de un arroyo
solitario lo pasaba,
en mil cosas cavilaba,
y a una güelta repentina
se me hacía ver a mi china
o escuchar que me llamaba.

Nada más justificado que el lamento criollo y ese tópico criollo de la


ausencia. Es una melancolía que llamaríamos territorial, topográfica. Y
ciertamente, si el gaucho encuentra algunas ocasiones de felicidad, su
posición en el mundo le hace apto para la melancolía.
No es que sea sombrío, ni que le falte lo esencial a la vida; en los buenos
tiempos de Martín Fierro, y aún ahora generalmente, el paisano[25] dispone
de un caballo en que trotar, el amor lo encuentra fácil, un cobertizo y un
poncho le son suficientes para cubrirse, y la carne, base casi única de su
alimentación, la cobra sin ninguna dificultad. El trabajo es fácil también.
Detesta el manejo de la azada y no gusta el oficio de labrador, que abandona
a los gringos; pero es insuperable caballista, cuida como nadie de los
ganados, sabe esquilar ovejas y domar potros y herrar lindamente, y es
inapreciable, insustituible, en una estancia[26]. Bebe, rasguea su guitarra,
canta por lo fino. Gallardea en las fiestas, y sobre su dócil caballo, a la
madrugada, tendido al galope y con el lazo revoleado diestramente en
medio de la manada cerril, siente sin duda el robusto goce de la vida plena,
libre y masculina.
Pero delante de sus ojos, ¡cómo es de igual y plana la llanura! He allí un
mar de hierba, monótono e inexorable como el Océano. Vagamente llega al
alma una tristeza que no es la del marino, porque el marino va, y el gaucho
no saldrá nunca de su profunda soledad. El jinete se endereza sobre su
corcel, y no columbra nada a lo lejos, ni un pueblo, ni una roca, ni un
campanario; acaso una cabaña, sombreada por un sauce llorón, o un
ombú[27], el solitario árbol de la Pampa que no forma nunca bosque. Sólo el
blanquear de las ovejas, y el mugido de los toros errantes y apaciguados. Un
amanecer de oro, un mediodía azul, un crepúsculo lleno de nostalgias. El
cielo y la llanura, tan anchos, tan infinitos, concluyen por parecer muros de
limitación... Sólo el viento pampero, de largo en largo, brota súbito como
del mismo seno de la llanura y hace estremecer los pajonales y retumba
siniestra y poderosamente en la infinita soledad del desierto.
CAP Í T U L O VI

El Cuchillo del Gaucho

P OR entre los versos del Martín Fierro brilla con frecuencia el cuchillo
de nuestro gaucho errante, y con esa arma compañera se consuman
hazañas increíbles, como el resistir en pleno campo abierto a un pelotón
de soldados policiales.
Viajando una vez por la provincia de Entre Ríos, cuyo paisaje algo seco
y surcado de pelados oteros recuerda bastante al campo de Castilla,
sorprendí un hombre a caballo, verdadera imagen del romancesco tipo del
gaucho. Ya no vestía chiripá, pero en su defecto portaba unos anchísimos
calzones bombachos, y sobre la erguida cabeza llevaba un sombrero
afieltrado, con masculino y coquetón talante. Al girar de espaldas, mostró
en el cinto, por la parte de los riñones, cruzado un largo cuchillo de punta
sutil. Mientras el tren arrancaba con enfática carrera, el hombre del caballo
y del cuchillo se internó serenamente en la llanura, bien tieso en su silla
nacional, impasible y orgulloso, como una página del pasado que se vuelve
y huye...
He nombrado el cuchillo, y la palabra no es justa del todo. El cuchillo o
facón gauchesco era más bien una espada. Sus dimensiones tenían una
prudente medida, y si era demasiado largo para cuchillo, quedaba algo corto
para llegar a espada. El gaucho no podía llevar una espada al cinto, como
un soldado de caballería; su manera violenta y continua de cabalgar, y su
deseo de no separarse nunca del arma fiel, le obligó a cortar la espada del
caballero o del hidalgo. La cruzó en la cintura, la sujetó a su cuerpo, y así
logró convertirla en algo indivisible con su persona.
Al referirme al cuchillo del gaucho hablo en pretérito, porque el arma
nacional de los ríoplatenses va desapareciendo, y sólo es usado tal vez en
las comarcas desviadas. El europeo ha traído el uso del revólver, arma fácil
y expedita que no requiere una maniobra tan complicada como aquel acero
filoso, únicamente eficaz cuando la mano, la vista y el corazón del gaucho
lo esgrimía en los imponentes entreveros[28].
Tampoco podía el europeo desenvolverse en el seno de la Naturaleza,
desafiarla y vencerla como el gaucho. Este hombre primitivo contaba
solamente con su voluntad y sus iniciativas. Situado en mitad del desierto,
se buscaba un camino, se orientaba por las huellas sutiles de la luz o del
color y sabor de las hierbas, y nada quedaba para él sin expresión, desde el
vuelo de las aves hasta el mugido de las bestias errabundas. Poco debía
contar con la justicia ni con los poderes constituidos; en último caso fiaba a
su acero la defensa de su familia y de su prestigio personal. El europeo,
debilitado por la civilización, procura reconciliarse con la Naturaleza, y al
reñir contra ella no marcha de frente, sino que la soslaya, y pone por medio
la mecánica de la industria y la otra mecánica de las leyes colectivas.
Un pueblo entero, libre y robusto, usaba hasta ayer mismo la espada del
caballero o del hidalgo, como hace dos o tres siglos la usaban en Europa las
gentes nobles. No se olvide que la espada significa libertad, aunque las
mentes un poco aturdidas por la democracia tomen esto por una blasfemia.
La espada no ha sido nunca negocio de esclavos, porque implica el sentido
de la mayor independencia personal. La espada hace sagrado el concepto de
la personalidad, y un hombre que la lleva al cinto está significando a todos
los otros hombres que su independencia personal comienza desde la misma
punta de su espada. Los caballeros del siglo XVI, llevando todos el signo
acerado y mortífero de la libertad, por imposición natural interponían entre
ellos la virtud más deseable y democrática: el respeto mutuo.
Así Pizarro, detenido en la isla del Gallo por las suspicacias de algunos
compañeros, cuando quiso arrastrar su gente a la gran aventura de
conquistar el Perú no osó proferir gritos y órdenes de mando, sino que sacó
la espada, rayó la tierra con un brusco ademán y empezó: ¡Señores...!
Aquellos hidalgos trajeron la espada a la llanura ríoplatense, y el gaucho,
pobre y errante como su progenitor, lleno de sus mismos prejuicios, reacio a
la industria, atento al honor y a la libertad más que al ahorro, fué un
testamentario y un continuador en América de la tradición castellana.
Cuando en la tierra originaria no quedaron hidalgos de espada al cinto, en la
Pampa vivía el gaucho una vida hidalguesca, con su caballo y su daga, su
puntillo de honor y su aventura.
No; no era para todos el manejo de la daga gauchesca. Nada tan
complicado como su esgrima, ni nada tan terrible como un hombre de
aquellos cuando enrollaba al brazo el poncho, se quitaba las grandes
espuelas y hacía brillar la hoja del cuchillo. A veces las pendencias duraban
mucho tiempo, y el sudor bañaba los rostros que la ira hacía enrojecer. Los
circunstantes formaban en círculo, y a nadie se le ocurría que podía
intervenir en aquel torneo legal y honroso. Juntos los pies de ambos
luchadores, casi abrazados los dos, hacían largo tiempo culebrear los
aceros, parándose los tajos con el poncho, ladeándose, evitándose como
ágiles reptiles. Un chirle en la cara era golpe muy apreciado, y a veces
bastaba la herida del rostro para lavar una ofensa. Pero los verdaderamente
bravos no se contentaban con tan poco. Martín Fierro era hábil en hundir el
cuchillo hasta la empuñadura.
Yo tenía un facón con S[29]
que era de lima de acero;
le hice un tiro, lo quitó
y vino ciego el moreno.

Y en el medio de las aspas


un planazo le asenté,
que lo largué culebriando
lo mesmo que buscapié.

Le coloriaron las motas


con la sangre de la herida,
y volvió a venir furioso
como una tigra parida.

Y ya me hizo relumbrar
por los ojos el cuchillo,
alcanzando por la punta
a cortarme en un carrillo.

Me hirvió la sangre en las venas


y me le afirmé al moreno,
dándole de punta y hacha
pa dejar un diablo menos.

Por fin en una topada


en el cuchillo lo alcé,
y como un saco de güesos
contra un cerco lo largué...

Acabada la riña, Martín Fierro atraviesa por entre los silenciosos


espectadores sin volver la mirada, convencido de que nadie habrá de poner
una objeción a su terrible y lógico comportamiento.
Limpié el facón en los pastos,
desaté mi redomón,
monté despacio, y salí
al tranco pa el cañadón...

En otro capítulo se verá la forma de pelea y el sentido de la muerte del


gaucho.
CAP Í T UL O VI I

Hazañas y Entreveros

E L uso consumado de la esgrima trae consigo una especie de culto de la


serenidad; el esgrimidor, por lo mismo que cuenta con su destreza y
quiere atestiguarla, se cuida mucho de mostrar una firme sangre fría al
momento de la pelea.
El gaucho hace esgrima desde que nace, y en su mano se convierte el
facón en un prodigio. No le gusta, por tanto, combatir de un modo brutal y
torpe; estima grato rodear el trance del peligro con el adorno de esas gracias
marciales que consisten en jactanciosas actitudes, ademanes despectivos y
palabras hirientes. Desde los tiempos del padre Homero, el hombre que fía
su riesgo a la entereza de su mano y de su espada ha sentido siempre el
trágico placer de irritar, de encolerizar al adversario, y demostrarle cuán
poco terror alberga el pecho que se prepara a combatir.
El gaucho es un buen hijo de español, y sufriría mucho si le privaran del
ácido y supremo placer de la jactancia varonil frente a la muerte. Ha
heredado del andaluz el culto del gesto y la graciosa arrogancia del
desplante masculino; antes de herir, se reserva el derecho de lanzar la frase
punzante y retadora. Sus riñas suelen tener un prefacio terrible,
emocionante, en que los contendientes se atacan con miradas y con palabras
frías, con frases de ambiguo sentido, con sonrisas que cortan.
Era natural que en un ambiente así apareciera el tipo del matón. Lo hubo
antes, y ahora mismo existe, sobre todo en los suburbios de las grandes
poblaciones. Llaman en Buenos Aires orilleros (sin duda por ser vecinos de
las orillas urbanas) a unas gentes confusas, bastante híbridas, formadas de
todos los restos de población indígena y forastera, con sedimentos criollos y
mucha aportación italiana, especialmente de las partes de Nápoles, Calabria
y Sicilia. En esta población circundante y procelosa surge con frecuencia el
tipo del guapo, del chulo, del apache, que en el lenguaje provincial del país
llaman compadrito. Antiguamente se titulaba compadre a secas, y la palabra
ha dado origen a un verbo muy usado, compadrear, que significa hacer el
gallo, el guapo o el valentón; pero en la chulería arrabalesca, allí como en
los bajos fondos sociales europeos, el valentón busca siempre la manera
diminutiva o afeminada de mostrar su terrible y repugnante masculinismo.
El compadre, pues, se convierte en compadrito, hombre pálido y cruel,
apachesco, fríamente sanguinario, portador del revólver o del cuchillo,
espejuelo de las infelices y deslumbradas mujeres, y diestro bailador de ese
soez tango argentino que, en efecto, los argentinos honrados nunca
quisieron bailar, y en Europa lo han bailado las atolondradas señoritas
linajudas.
Del gaucho Martín Fierro no se puede decir que sea un compadre
militante. Obedece, sí, a la ley de su patria, y tomando un poco más de
ginebra se siente algo provocador y demasiadamente dicharachero. Por
soltar con exceso la lengua se ve obligado una vez a reñir con un negro, al
que tiene la desgracia de rajar el vientre. Son cosas de la fatalidad, que hoy
toca a uno y mañana nos escogerá a nosotros. Efectivamente:
Otra vez en un boliche
estaba haciendo la tarde;
cayó un gaucho que hacía alarde
de guapo y de peliador.

A la llegada metió
el pingo hasta la ramada,
y yo sin decirle nada
me quedé en el mostrador.

Era un terne de aquel pago


que naides lo reprendía,
que sus enriedos tenía
con el señor Comendante.

Y como era protegido


andaba muy entonao,
y a cualquiera desgraciao
lo llevaba por delante.

¡Ah, pobre! ¡si él mismo creíba


que la vida le sobraba!
Ninguno diría que andaba
aguaitándolo la muerte.

Sabe ya Martín Fierro, desde la aparición del compadre en la pulpería,


que las cosas no podrán ir bien para todos. Antes de que estalle la tormenta,
el héroe hace unas cuantas reflexiones filosóficas, seguramente no exentas
de curiosidad.

Pero ansí pasa en el mundo,


es ansí la triste vida;
pa todos está escondida
la güena o la mala suerte...

Observad ahora la manera especial de desarrollarse una pendencia entre


gauchos:
Se tiró al suelo al dentrar,
le dió un empellón a un vasco,
y me alargó un medio frasco
diciendo: “Beba, cuñao.”
“Por su hermana, contesté,
que por la mía no hay cuidao.”

“¡Ah, gaucho!,” me respondió,


“¿de qué pago será crioyo?
¿Lo andará buscando el hoyo?
¿Deberá tener güen cuero?...
Pero ande bala este toro
no bala ningún ternero.”

Y ya salimos trenzaos,
porque el hombre no era lerdo;
mas como el tino no pierdo
y soy medio ligerón,
le dejé mostrando el sebo
de un revés con el facón.

Pero estas son riñas de uno contra uno, de forma caballeresca popular y
muy semejantes a las riñas de otros países. Donde se prueba el valor del
gaucho y la potencia de su cuchillo y de su esgrima, es en los entreveros de
uno contra muchos, o en la pelea contra un indio armado de boleadoras.
Me encontraba, como digo,
en aquella soledá,
entre tanta oscuridá
echando al viento mis quejas,
cuando el grito del chajá[30]
me hizo parar[31] las orejas.

Como lombriz me pegué


al suelo para escuchar;
pronto sentí retumbar
las pisadas de los fletes[32],
y que eran muchos jinetes
conocí sin cavilar...

Al punto me santigüé
y eché de giñebra un taco;
lo mesmito que el mataco[33]
me arrollé con el porrón.
“Si han de darme pa tabaco,
dije, esta es güena ocasión.”

Me refalé las espuelas


para no peliar con grillos,
me arremangué el calzoncillo
y me ajusté bien la faja;
y en una mata de paja
probé el filo del cuchillo...

Yo quise hacerles saber


que allí se hallaba un varón;
les conocí la intención
y solamente por eso
fué que les gané el tirón,
sin aguardar voz de preso.

“Vos[34] sos un gaucho matrero,”


dijo uno haciéndose el bueno
dijo uno, haciéndose el bueno.
“Vos matastes un moreno
y otro en una pulpería,
y aquí está la polecía
que quiere ajustar tus cuentas.
Te va a alzar por las cuarenta
si te resistís hoy día.”

“No me vengan, contesté,


con relación de difuntos;
esos son otros asuntos;
vean si me pueden llevar,
que yo no me he de entregar
aunque vengan todos juntos.”

Pero no aguardaron más


y se apiaron en montón.
Como a perro cimarrón
me rodiaron entre tantos.
Yo me encomendé a los Santos
y eché mano a mi facón...

¿No es cierto que nos figuramos leer un folletín de Alejandro Dumas o


de Fernández y González? Las estupendas luchas que nos describen las
novelas de capa y espada, podrán, y tienen de seguro muchas veces, una
parte importante de mentira. En nuestro caso no hay exageración, porque
los anales de la Pampa están llenos de empresas parecidas, y el honrado
José Hernández, además, rehuye siempre las narraciones hiperbólicas. El
gaucho Martín Fierro saca fuerzas de flaqueza, y aunque está solo en la
inmensidad, frente a varios hombres armados, sin más apoyo que su daga,
prefiere morir matando, y no que lo sacrifiquen miserablemente.
Para nuestra pasibilidad de hombres civilizados, urbanos y tímidos, la
actitud de un hombre luchando contra muchos nos resulta inverosímil. Pero
Martín Fierro no está precisamente solo. A nosotros nos serviría para poco
una daga punzante y un cuerpo más o menos dañado de artritismo; en
cambio Martín Fierro le saca a su facón imprevistas y maravillosas
aptitudes, y cada canto o punto de su daga es un resorte poderosísimo. En
cuanto a su cuerpo físico, él se estira y encoge como la goma, salta o se
soslaya, se acurruca o se acrecienta, se multiplica verdaderamente. Y hay,
además, la astucia.
Es así como un “hombre de guerra”, un guerrero de oficio, ha sido en la
Historia una cosa resistente y capaz de proezas increíbles. Los héroes de
Homero, por ejemplo, el Aquiles y el Agamenón y el Ayax, eran completos
y vigilantes esgrimidores que aterraban a sus enemigos. Cuando leemos en
los libros de Caballería que un solo guerrero combatía y derrotaba a
innúmeros adversarios, no todo cuanto nos cuentan es mentira. Un guerrero
antiguo, por virtud de la esgrima, del oficio y de la especial preparación del
alma, valía por muchos hombres juntos. El gendarme, el lansquenete, el
suizo, y sobre todo el caballero marcial a lo Rolando, Cid y Gonzalo de
Córdoba, hicieron en mucho tiempo imposible la formación de grandes y
eficaces ejércitos anónimos, democráticos, al estilo moderno.
Los enemigos de Martín Fierro traen, es verdad, alguna carabina; pero
aquellos pobres fusiles de pistón, sobra sin duda de los arsenales europeos,
no valen gran cosa.

Y ya vide el fogonazo
de un tiro de carabina;
mas quiso la suerte indina
de aquel maula, que me errase,
y ahí no más lo levantase
lo mesmo que una sardina...

Era tanta la afición


y la angurria[35] que tenían,
que tuítos se me venían
donde yo los esperaba;
uno al otro se estorbaban
y con las ganas no vían.

He aquí ahora que interviene la astucia, puesto que el guerrero ha de ser


listo en ardides:
Dos de ellos que traiban sables,
más garifos y resueltos,
en las hilachas envueltos
enfrente se me pararon,
y a un tiempo me atropellaron
lo mesmo que perros sueltos.

Me fuí reculando en falso


y el poncho adelante eché,
y cuando le puso el pie
uno medio chapetón[36],
de pronto le dí el tirón
y de espaldas lo largué...

Pegué un brinco y entre todos


sin miedo me entreveré.
echo ovillo me quedé,
y ya me cargó una yunta[37],
y por el suelo la punta
de mi facón les jugué.

El más engolosinao
se me apió con un hachazo;
se lo quité con el brazo,
de no, me mata los piojos;
y antes de que diera un paso
le eché tierra en los dos ojos.

Y mientras se sacudía
refregándose la vista,
yo me le fuí como lista
y ahí no más me le afirmé,
diciéndole: “Dios te asista”,
y de un revés lo voltié...
En fin, la feroz pelea de uno contra tantos acaba, o se precipita al
desenlace, cuando uno de los soldados, el sargento Cruz, se pasa al campo
de Martín Fierro, gritando aquella voz quijotesca:

...¡Cruz no consiente
que se cometa el delito
de matar ansí un valiente!
C AP Í T UL O VI I I

Los Indios

C UANDO un hombre se ponía fuera de la ley, quedábale antiguamente


en la Argentina el desesperado recurso de hacerse gaucho matrero,
oficio semejante al de nuestro histórico bandido de Sierra Morena. El
matrero se contentaba con robar ganado, que vendía a los falaces
intermediarios, y vagaba errante por la inmensidad de la llanura, libre y
abierta entonces.
Hoy la llanura se ve toda dividida y reglada por fuertes alambrados, que
si no impiden las raterías y los vagabundajes, dificultan mucho las antiguas
aventuras.
En aquellos tiempos le quedaba todavía otra solución al perseguido por
la ley: los indios en sus tolderías reservaban a veces un asilo a los
cristianos, en la esperanza de utilizarlos como rehenes o a título de espías.
Martín Fierro y el sargento Cruz se marcharon, pues, al país de los indios
pampas.
El poema del Martín Fierro, aunque no tiene más que cuarenta años de
fecha, guarda un valor inestimable porque describe cuadros y cosas que ya
desaparecieron de la Argentina. En aquel país nuevo, en constante
evolución, las cosas vienen y van con alucinante rapidez.
Este poema vulgar y sin pretensiones tiene, pues, una importancia
grande como documento vivo y veraz. Narra, por ejemplo, la vida de los
indios, cuando todavía vagaban los indios feroces y libres en los confines de
la misma provincia de Buenos Aires. Y los describe con tal detalle y con
tanta realidad, que nosotros, los lectores, podemos asistir a las fiestas y las
batallas de aquellos bárbaros, a quienes la civilización no ha podido o no ha
querido amansar. En estos momentos los indios feroces, constante alarma
de los poblados fronterizos, no existen ya más. Todos han desaparecido.
Permanecen algunas tribus, es cierto, en los territorios meridionales de la
Patagonia y en la Tierra de Fuego. Pero son indios nada bravos,
entumecidos en su clima implacable, poco numerosos y cada día más
mermados ante el avance de la colonización. También existen núcleos de
indios salvajes en la zona tórrida del Norte de la República, y aunque más
numerosos que los del Sur y bastante crueles y rapaces, nunca forman un
grave peligro para la población laboriosa del país. Se sostienen en el casi
desierto territorio del Chaco y arman sus tolderías en las riberas del poco
conocido Pilcomayo. Se valen de la pesca y la caza para subsistir; a veces
arrostran pequeños malones[38] o saqueos sobre los colonos cristianos; otras
veces acuden a trabajar por temporadas en los obrajes[39], donde se cortan y
preparan grandes cantidades de la madera tintórea llamada quebracho. Los
miserables indios reciben por sus trabajos alguna suma, que invierten en
armas y en alcohol; con frecuencia son víctimas de la codicia de los
capataces, y ellos se vengan en brutales represalias.
Los verdaderos indios, los peligrosos y terribles, eran los pampas.
Antiguamente se llamaban querandíes, y ocupaban toda la zona llana de la
Argentina, esa infinita pradera verde, limpia de árboles. Los indios del
Uruguay, llamados charrúas, no eran menos valerosos y crueles.
Por su crueldad, su valor y su independencia, los indios pampeanos eran,
sin duda, de la misma condición y raza que los araucanos. Los primeros
conquistadores, cuando pretendieron establecerse en la desembocadura del
Plata, soportaron bien pronto los excesos de los indios. Los charrúas, cerca
de la actual Montevideo, asaltaron la expedición de Solís y la deshicieron.
El capitán Hurtado de Mendoza llegó a la Argentina con un lucido ejército
de nobles y buenos soldados, fundaron la ciudad de Buenos Aires, y al poco
tiempo, los indios querandíes sitiaron la ciudad, sembraron el hambre en la
colonia, y, por último, con flechas encendidas quemaron las casas de
madera y paja y abrasaron las mismas naves ancladas sobre la ribera. La
expedición fracasó del todo, y hubo de llegar más tarde con nueva gente el
capitán Blasco de Garay a reedificar las chozas y el castillo de Buenos
Aires. Y desde entonces la civilización ha tenido que bregar continuamente
en la Argentina con los fieros e irreductibles indios. Hasta que finalmente,
bajo el gobierno del general Roca, se acordó una expedición al desierto, y
los indios, implacablemente, fueron exterminados. Las mujeres y los niños
que se salvaron de la encerrona ingresaron, por adopción, en la masa de la
población civilizada.
Bárbaros y feroces, los indios de la Pampa necesitaron sufrir, en pleno
siglo XIX, igual suerte que los pieles rojas. La civilización tiene un fondo
de egoísmo inapelable; la civilización ambiciona nuevos territorios, nuevas
adquisiciones, y quien se resiste ha de desaparecer. No hicieron otra cosa
los españoles del descubrimiento y la conquista. Además de la ambición
adquisitiva, los españoles llevaron a América el deber ambicioso de la
Religión, de cuya carga estuvieron libres los yanquis y los argentinos. Estos
pedían al indio sus tierras feraces, sus minas, sus ríos, y que no molestaran
mucho a los colonos; cuando el indio se negó, fué exterminado. En algún
trozo de los Estados Unidos, a manera de curiosidades etnográficas, quedan
hoy unos pocos pieles rojas; también en la Argentina restan unas docenas
de indios pampas, a quienes el Gobierno entrega, a título precario y sin
carácter de propiedad absoluta, unas tierras para pastorear.
Los españoles exigían a los indios la sumisión, el oro y las tierras. Si los
indios accedían, eran conservados bajo leyes humanas; entraban, asimismo,
en la comunidad carnal de los hombres blancos por medio del matrimonio.
Si se resistían al dominio del rey o de la Iglesia, eran perseguidos y
muertos. Después de largas luchas y persecuciones, los indios podían
aspirar a que los españoles les admitieran en el organismo civil de los
virreynatos. Es cierto que había las encomiendas y la prestación personal
del indio en el trabajo de las minas y la agricultura; ¿pero hoy no existen los
obrajes, el alcohol, las persecuciones? ¿No se ha extirpado al indígena de la
Nueva Zelandia en nuestro propio tiempo?
Saquear y matar; he aquí el oficio de los indios pampas. Hacían
acometidas tumultuosas, que llamaban malones, y cayendo sobre los
poblados pacíficos, se llevaban lo que veían a mano: mujeres, niños,
comestibles, aperos, rebaños.
Antes de aclarar el día
empieza el indio a aturdir
la pampa con su rugir,
y en alguna madrugada,
sin que sintiéramos nada,
se largaban a invadir.

Primero entierran las prendas


en cuevas como peludos[40],
y aquellos indios cerdudos,
siempre llenos de recelos,
en los caballos en pelos
se vienen medio desnudos.

Para pegar el malón


el mejor flete procuran,
y como es su arma segura
vienen con la lanza sola,
y varios pares de bolas
atados a la cintura...

Se vuelve aquello un incendio


más feo que la mesma guerra;
entre una nube de tierra
se hace allí una mescolanza
de potros, indios y lanzas,
con alaridos que aterran...

Y aquella voz de uno solo,


que empieza con un gruñido,
llega hasta a ser alarido
de toda la muchedumbre.
Y ansí adquieren la costumbre
de pegar esos bramidos.

El gaucho Martín Fierro no conserva buena memoria de los indios. No


les concede ninguna cualidad. Su pintura, en fin, es perfectamente contraria
a aquel hombre de la Naturaleza que inventara Rousseau y que estuviera en
moda hasta acabar el imperio del romanticismo. Nuestro fantástico padre
Las Casas, el bueno de Bernardino de Saint Pierre y el mismo
Chateaubriand, palidecerían de rubor ante este retrato del indio pampa.
El indio pasa la vida
robando o echao de panza.
La única ley es la lanza
a que se ha de someter.
Lo que le falta en saber
lo suple con desconfianza.

Fuera cosa de engarzarlo


a un indio caritativo.
Es duro con el cautivo,
le dan un trato horroroso.
Es astuto y receloso,
es audaz y vengativo...

Odia de muerte al cristiano,


hace guerra sin cuartel.
Para matar es sin hiel.
Es fiero de condición.
No golpea la compasión
en el pecho del infiel...

Se cruzan por el desierto


como un animal feroz.
Dan cada alarido atroz
que hace erizar los cabellos.
Parece que a todos ellos
los ha maldecido Dios.

Todo el peso del trabajo


lo dejan a las mujeres.
El indio es indio, y no quiere
apiar de su condición.
Ha nacido indio ladrón,
y como indio ladrón muere.

Ahora vamos a reproducir estos versos, que explican simple e


ingenuamente una de las características principales del indio americano: la
incapacidad para la risa.

El indio nunca se ríe


y el pretenderlo es en vano,
ni cuando festeja ufano
el triunfo en sus correrías.
La risa en sus alegrías
le pertenece al cristiano...

Es verdad; la aptitud para la risa pertenece a la raza blanca, y a esos


hermanos inferiores que son los negros. Impasible es el japonés; sombrío y
siniestramente grave es el malayo; y el indio americano no acertó nunca a
poner risa o amabilidad en sus ídolos; su religión precolombiana era de
esencia mortal, sanguinaria, fríamente sacrificadora de víctimas humanas.
Lo distintivo en el indio de América es una como fundamental tristeza, y
una casi insensibilidad para el horror de la muerte. De tal modo, que el
europeo observa ahora mismo, entre las personas mestizadas de la
Argentina, una extraña sobriedad en el reir. En cuanto a la insensibilidad
ante la muerte, el europeo nota con extrañeza cuán poco valor tiene allí la
vida humana, cuán fácil es allí el homicidio, y qué escaso valor se le otorga
al delito de sangre. Los señoritos de la buena sociedad portan en la
Argentina, con mucha frecuencia, el revólver bajo el smokin. Cierta vez, en
pleno Parlamento, a un senador, al agacharse, se le desprendió el revólver
del bolsillo; y los periódicos de la mañana no se indignaron ni un poco, sino
que hicieron al efecto alguna broma.
Los indios existen todavía, y existirán siempre en América, bien sea en
estado semisalvaje o como adscritos a la civilización. En la Argentina no es
menos importante el elemento indio. Cuando se nos habla de una raza
blanca y europea en la región platense, debemos entender que se trata de un
núcleo inmigrante, puramente moderno y pegadizo, y habitador de las
ciudades costeñas. El resto del país, precisamente el país que más motivos
tiene para llamarse argentino, está compuesto de gentes mestizas.
Todo el interior de la Argentina, desde Mendoza a Jujuy, desde
Catamarca a Corrientes, es de raza hispano-india; en la provincia de
Corrientes aún habla hoy el pueblo un idioma aborigen, el guaraní. A esta
población mestiza, que a veces tiene más sangre india que española, llaman
en el país con el mote de chinos, por sus caracteres especiales, que
recuerdan mucho a los de los japoneses: pómulos pronunciados, ojos un
tanto oblicuos y color amarillento.
Las familias argentinas de apellido y abolengo español, especialmente
aquéllas muy antiguas que proceden de las ciudades interiores, tienen casi
siempre los rasgos del mestizo. Los hombres más significados de la
Argentina suelen tener igualmente sangre india, como Sarmiento, como
Lugones, como Ricardo Rojas.
***
Una vez, con motivo de ciertas asonadas que realizaran los indios del
Chaco, fué comisionado por el Gobierno argentino el Sr. Lynch Arribálzaga
para estudiar aquel problema. El dictamen que presentó dicho señor me
produjo mucha curiosidad y lo leí con verdadera emoción.
“El indio no sólo no es agricultor, sino que carece de la noción misma de
la propiedad individual, salvo la de los vestidos y utensilios domésticos; el
campo, los ríos y los lagos, considerados como territorios de caza y pesca,
pertenecen en común a los individuos de cada tribu, dentro de límites
convencionales que no pueden ultrapasar los vecinos sin consentimiento.
En cuanto a los alimentos, bebidas, etc., el concepto de su propiedad es
comunista, a tal punto, que si vuelven con un solo pescado, lo reparten
equitativamente entre todos, aunque toquen a bocado por barba. La caza
mayor se la dividen sobre el terreno, y es frecuente ver una rueda de
salvajes fumando en común un cigarro o una pipa, que pasa por turno de
boca en boca.”
Ya se comprende que estos hombres arbitrarios, que carecen de la idea
del ahorro y de la propiedad territorial, habían de ser perseguidos sin
compasión... ¡Miserables, infelices, odiosos indios!
Habían de ser exterminados sin remedio, porque no querían ahorrar,
guardar, aumentar. Porque no saben separar la tierra con hitos y mojones.
Porque no sienten la bondad del magno sistema, que consiste en alquilar
peones y reservarse el noventa por ciento de los beneficios. No comprenden
la sabiduría de guardarse el fruto del trabajo ajeno. Entienden que la
libertad es el supremo placer, y que la Naturaleza lo da todo generosamente:
peces, aves, frutos, flores y plumas. No son útiles para la civilización, desde
el momento que no conciben la necesidad de un portamonedas.
El concepto blanco de la vida está en oposición con el de las razas de
color: el sol tropical es el enemigo irreparable. Tienen esas razas un sentido
frágil del vivir; por otra parte, la Naturaleza les da lecciones convincentes
cada día; conocen, en fin, “la facultad de existir sin esfuerzo”. Frente al
salvaje, el blanco marcha bajo la obsesión de reunir, acumular y vencer. El
espíritu de acumulamiento forma todo el sentido de nuestra civilización.
Situado en un clima adverso, el blanco siente miedo a la vida. Es el
miedo al frío, a la humedad, al hambre, a la casa sin techo; es el miedo al
día de mañana, a la incógnita de un mañana atenaceante; por último, el
miedo a la vida forma hábitos inconscientes de alquisición. Perfeccionados
los medios de adquisición, el hombre civilizado ya no busca lo necesario,
sino lo superfluo; necesita adquirir, porque se ha hecho en él un vicio
sobremanera incitante. Se crean además necesidades de lujo, de arte, de
ostentación y de sensuales delicadezas.
Tiranizado por su pasión, el blanco se abandona a su vida dionisíaca, en
que la lucha es suprema ley. Un sabio hebreo lo dejó escrito en palabras
imborrables, sobre las páginas insuperables del Eclesiastés: “La vida es una
batalla...” Ahí está la síntesis filosófica de nuestra civilización. El indio la
rechaza, porque entiende la dicha de otra manera. Se vituperan los
procedimientos del hombre de los climas cálidos; pero es porque nos ciega
la soberbia de nuestro circunscripto razonamiento. ¿Cómo podemos pedir el
mismo esfuerzo, la misma tensión laboriosa a un indígena del Chaco y a un
obrero inglés? Este necesita trabajar mucho, porque exige carne, manteca,
verduras, patatas, pan, cerveza, tabaco, calefacción, casa abrigada, vestidos
de lana, distracciones con que atenuar sus horas de niebla interminable;
pero a un hombre de clima cálido le basta un puñado de bananas, un techo
de paja y un lienzo que cubra sus vergüenzas. Los que manejan ingenios y
obrajes en el norte de la Argentina, gritan porque los obreros se van a media
tarea, exigiendo su breve jornal; pero ¿qué ley, humana o divina, puede
obligar a un hombre a que trabaje sin cesar todas las jornadas del año, si no
tiene necesidad de dinero? Con el dinero que le otorguen después de una
faena esforzada, ¿comprará ese hombre alguna cosa de más valor que su
muelle y dichosa holganza?...
Por eso hay que aceptar al indio como es, sin exigirle que adopte todas
nuestras preocupaciones; siempre será un semicivilizado. Y probablemente
serán siempre los países cálidos una especie de “territorios protegidos”.
Contra el fatalismo de la Naturaleza es inútil luchar. Los pueblos calientes

You might also like