The key to writing a Puppet list is modular structure, resource relationship management, flexible application of variable conditions and standardized grammar style. 1. Use a modular structure to split the functions into modules and store them in directories, place the main class init.pp, and respond to different scenarios through subclasses to improve reusability; 2. Reasonably declare resources and manage dependencies, use before, require, and notify to control the execution order, and ensure that the service restart is triggered after the configuration file is modified; 3. Use variables and condition judgments to improve flexibility, select paths according to the system type, and manage configuration data in combination with Hiera; 4. Pay attention to the code style, unify naming specifications, align indentation, add clear annotations, and use the Puppet Lint tool to ensure the correct format.

It is actually not difficult to write a Puppet list (Manifests), but you have to master a few key points. Puppet defines the system status through a list, so if it is well written, the automated configuration will be smooth; if it is written in a mess, it will be a headache to maintain. This article talks about some practical tips to help you write a clear and easy-to-maintain Puppet list.

1. Use a modular structure

Puppet's most recommended way is to split the configuration into a module. A module usually corresponds to a function or service, such as nginx , mysql , etc. This not only has a clear structure, but also facilitates reuse and testing.

• Each module should have its own directory, including subdirectories such as manifests/ , files/ , templates/ etc.
• The main class (main class) is placed in the init.pp file
• If there are multiple configuration scenarios, you can use subclasses to organize them

For example: If you are deploying a web server, you can write Nginx, configure virtual hosts, and set up firewalls into different classes, and then call them in a "site.pp".

Another advantage of modularization is that it is convenient for parameterization. You can use parameters to adapt the same module to different environments (such as development, testing, and production).

2. Rational use of resource statements and relationship management

The core of Puppet is resources, such as package , file , and service . When writing a list, you should not just simply write "install this package", but also pay attention to the dependencies between resources.

Common practices are:

• Use ensure => present or installed to ensure the software is installed
• Configuration files are managed with file resources and generated from templates ( template() function)
• The service should be set to start and enable power-on self-start: enable => true, ensure => running

What's more important is the order of processing resources. For example, you cannot start the service first and then change the configuration file. At this time, you can use before , require , and notify to control the execution order.

 file { '/etc/nginx/nginx.conf':
  ensure => file,
  source => 'puppet:///modules/nginx/nginx.conf',
  notify => Service['nginx'],
}

service { 'nginx':
  ensure => running,
  enable => true,
  hasrestart => true,
}

In the above example, when the configuration file is modified, the restart service will be automatically triggered.

3. Use variables and conditional judgments to improve flexibility

Puppet supports variables and conditional statements. Use it reasonably can make your list more flexible.

For example, select different configuration paths according to the operating system type:

 if $facts['os']['family'] == 'RedHat' {
  $config_path = '/etc/httpd/conf.d/'
} elsif $facts['os']['family'] == 'Debian' {
  $config_path = '/etc/apache2/sites-available/'
}

You can also extract common variables into module parameters, or centrally manage configuration data through Hiera, so that the list itself can be kept clean, only describe logic, and not put specific values.

4. Pay attention to syntax specifications and code styles

While Puppet's syntax is not as strict as programming languages, a good style will make your list easier to read and maintain.

A few suggestions:

• Class names and variable names are underlined in lowercase, such as $nginx_config
• All resource attributes are aligned and indented, and two spaces are recommended
• Multi-line list or hash is expressed by newline indentation
• Comments should be clearly used, especially in complex logic

If teamwork, consider introducing the Puppet Lint tool to check format issues.

Basically that's it. Writing a Puppet manifest is not writing a script, but describing the expected state. As long as the structure is clear, the logic is clear, and the dependencies are correct, automated operation and maintenance can be much easier.

The above is the detailed content of How to write Puppet manifests. For more information, please follow other related articles on the PHP Chinese website!