Saturday 14 April 2018

Extending SaltStack PDF Download - Joseph Hall

Extending SaltStack PDF Download 

 


Download Link is Below the Content Table,Click The Download Now Button for Download and Read Online for Read Online button without Download.

Author
Joseph Hall
Year
2016
Pages
388
Language
English
File Size
1.65MB
File Format
Pdf
Category
Cloud Computing
 


Here Below We Listed the Table which Contains the Content of the Book :

Table of Contents 

1.   
Extending SaltStack
2.   
Credits
3.   
Foreword
4.   
About the Author
5.   
About the Reviewer
6.   
eBooks, discount offers, and more
7.   
Why subscribe?
8.   
Preface
9.   
What this book covers
10.                    
What you need for this book
11.                    
Who this book is for
12.                    
Conventions
13.                    
Reader feedback
14.                    
Customer support
15.                    
Downloading the example code
16.                    
Downloading the color images of this book
17.                    
Errata
18.                    
Piracy
19.                    
Questions
20.                    
Starting with the Basics
21.                    
Using plugins
22.                    
Loading modules
23.                    
Standard modules
24.                    
Virtual modules
25.                    
Lazy loading modules
26.                    
Extending the loader system
27.                    
Loading modules with Python
28.                    
Detecting grains
29.                    
Using other detection methods
30.                    
Summary
31.                    
Writing Execution Modules
32.                    
Writing Salt modules
33.                    
Hidden objects
34.                    
The __virtual__() function
35.                    
Formatting your code
36.                    
Virtual modules
37.                    
Using the salt.utils library
38.                    
Cross-calling with the __salt__ dictionary
39.                    
Getting configuration parameters
40.                    
Handling imports
41.                    
Reusing code
42.                    
Logging messages
43.                    
Using the __func_alias__ dictionary
44.                    
Validating data
45.                    
Formatting strings
46.                    
The final module
47.                    
Troubleshooting execution modules
48.                    
Using salt-call
49.                    
<function> is not available
50.                    
Summary
51.                    
 Extending Salt Configuration
52.                    
Setting grains dynamically
53.                    
Setting some basic grains
54.                    
(Not) cross-calling execution modules
55.                    
The final grains module
56.                    
Creating external pillars
57.                    
Configuring external pillars
58.                    
Adding an external pillar
59.                    
Another external pillar
60.                    
Troubleshooting grains and pillars
61.                    
Dynamic grains not showing up
62.                    
External pillars not showing up
63.                    
Writing SDB modules
64.                    
Getting SDB data
65.                    
Setting SDB data
66.                    
Using a descriptive docstring
67.                    
Using more complex configuration
68.                    
The final SDB module
69.                    
Using SDB modules
70.                    
Troubleshooting SDB modules
71.                    
SDB data not showing up
72.                    
Summary
73.                    
Wrapping States Around Execution Modules
74.                    
Forming a state module
75.                    
Determining state
76.                    
The __virtual__() function
77.                    
Setting up defaults
78.                    
Checking for truth
79.                    
Checking for test mode
80.                    
Attempting to configure the resource
81.                    
Notifying about False
82.                    
Example: checking an HTTP service
83.                    
Checking credentials
84.                    
The first stateful function
85.                    
Another stateful function
86.                    
Troubleshooting state modules
87.                    
Step 1: test for truth
88.                    
Step 2: test mode
89.                    
Step 3: applying changes
90.                    
Testing opposites
91.                    
Summary
92.                    
Rendering Data
93.                    
Understanding file formats
94.                    
Serializing data
95.                    
Working with templates
96.                    
Using render pipes
97.                    
Building a serializing renderer
98.                    
The basic structure
99.                    
Building a templating renderer
100.             
Templating with Tenjin
101.             
Using a templating renderer
102.             
Troubleshooting renderers
103.             
Summary
104.             
Handling Return Data
105.             
Returning data to external destinations
106.             
Returning data to the master
107.             
Listening to event data
108.             
When returners listen to Minions
109.             
Your first returner
110.             
Using job caches
111.             
The final module
112.             
Troubleshooting returners
113.             
Testing with salt-call
114.             
Testing with the Master running
115.             
Testing with runners
116.             
Writing outputter modules
117.             
Pickling our output
118.             
Troubleshooting outputters
119.             
Summary
120.             
Scripting with Runners
121.             
Using Salt’s local client
122.             
Scripting with the local client
123.             
Using different targets
124.             
Combining jobs to add more logic
125.             
The final module
126.             
Troubleshooting runners
127.             
Working with the salt-master service
128.             
Timeout issues
129.             
Summary
130.             
Adding External File Servers
131.             
How Salt uses files
132.             
Mimicking a filesystem
133.             
Looking at each function
134.             
Setting up our module
135.             
envs()
136.             
file_list() and dir_list()
137.             
find_file()
138.             
serve_file()
139.             
update()
140.             
file_hash()
141.             
The final module
142.             
Troubleshooting file servers
143.             
Start small
144.             
Test on a Minion
145.             
Summary
146.             
Connecting to the Cloud
147.             
Understanding cloud components
148.             
Looking at the puzzle pieces
149.             
Connection mechanism
150.             
Listing resources
151.             
Creating virtual machines
152.             
Managing other resources
153.             
Libcloud versus SDK versus direct REST API
154.             
Writing a generic cloud module
155.             
Checking for required configuration
156.             
Using http.query()
157.             
A common REST API
158.             
GET
159.             
POST
160.             
PATCH
161.             
DELETE
162.             
Setting up a _query() function
163.             
Getting profile details
164.             
Listing images
165.             
Listing sizes
166.             
Listing locations
167.             
Listing nodes
168.             
Querying standard node data
169.             
Querying full node data
170.             
Creating a VM
171.             
Destroying VMs
172.             
Using actions and functions
173.             
Using actions
174.             
Using functions
175.             
The final cloud module
176.             
Troubleshooting cloud modules
177.             
Write avail_sizes() or avail_images() first
178.             
Use shortcuts
179.             
Summary
180.             
Monitoring with Beacons
181.             
Watching for data
182.             
Keeping an eye on things
183.             
Validating configuration
184.             
The beacon() function
185.             
Watching for beacons
186.             
The final beacon module
187.             
Troubleshooting beacons
188.             
Summary
189.             
11. Extending the Master
190.             
Using external authentication
191.             
Authenticating credentials
192.             
Troubleshooting external authentication
193.             
Setting auth parameters
194.             
Testing with the salt command
195.             
Testing with Salt API
196.             
Managing the Master with the wheel modules
197.             
Wrapping a wheel around runners
198.             
The final wheel module
199.             
Troubleshooting wheel modules
200.             
Summary
201.             
A. Connecting Different Modules
202.             
Separating Master and Minion functionality
203.             
Working with dunders
204.             
Using the event bus
205.             
Firing events
206.             
B. Contributing Code Upstream
207.             
How the community works
208.             
Asking questions and reporting issues
209.             
Using the mailing list
210.             
Using IRC
211.             
Using the issue tracker
212.             
Using GitHub markdown
213.             
Understanding the Salt Style Guide
214.             
Using Pylint
215.             
Creating pull requests on GitHub
216.             
Using other branches
217.             
Understanding test errors in pull requests
218.             
Index

In Case If You want anything else like Question Paper/Sample Paper/E-Book, Just go to the Contact us Page and write your query to us, we will contact you as soon as possible, and mail all the material to you.

To Download or Read Online Extending SaltStack PDF Click The Link Below






No comments:

Post a Comment