What this book covers
Chapter 1, Network Basics for Development, is focused on explaining the basics of computer networking and the jargon used. The idea is to build a good foundation to be built on throughout the book. If you are a network engineer or have experience in this field, you might want to skip it. If you are a software developer with little network experience, this chapter is for you. It will help you build a solid base of network jargon that will be useful when writing code for network automation.
Chapter 2, Programmable Networks, looks into several different technologies used today to create networks via software. Then we will examine the current standard technology, known as Software Defined Networks (SDNs).
Chapter 3, Accessing the Network, explores the most common methods and protocols for accessing network devices for our network automation. Since devices have multiple methods, we will aim to give you enough information so that you can choose the one that is most appropriate for your network automation code.
Chapter 4, Working with Network Configurations and Definitions, explores how to work with a network configuration and how to define it for effective use with network automation. We want to build scalable and future-proof solutions. The chapter answers why we need network definitions to help automation.
Chapter 5, Dos and Don’ts for Network Programming, focuses on the most important best coding practices for Python and Go related to network programming. Writing code for networks is exciting because when it fails, it is challenging, and when it works, it is rewarding. If you are an experienced programmer, it will be plain sailing, but if you are a newbie, it will be stormy. The chapter dives into some coding practices for Go and Python that will help you get through these storms more easily.
Chapter 6, Using Go and Python for Network Programming, looks at how Python and Go are powerful and useful for network programming, but depending on what the requirements are and the environment, one might be better suited than the other. We’ll also check the advantages and disadvantages of using Python and Go.
Chapter 7, Error Handling and Logging, explores how we report program execution events and how we handle errors. These two topics are not as easy as they seem, and they are, most of the time, implemented in systems poorly. The chapter investigates how and why we handle errors and then why and how we do event logging.
Chapter 8, Scaling Your Code, covers some techniques used today to scale your code up and down effectively, which will allow your solution to adapt easily to follow network growth, and, if necessary, easily scale down to save resources.
Chapter 9, Network Code Testing Framework, focuses on techniques to build a network testing framework that can be used for testing your network automation code. It also looks into advanced techniques that can be used to make your testing framework even more useful and reliable.
Chapter 10, Hands-On and Going Forward, explored building a network from scratch using the network automation skills we’ve learned and emulated routers. The finished emulated network will have enough components to experiment with several techniques described in the chapters of this book. And finally, there are a few remarks and some guidance for future studies and work.