Samples

Warning

Many of the examples were written a few years ago by the previous maintainers of PySNMP. They might still be valid and useful, but they might also be outdated and not reflect the best practices.

The most reliable resources to see the API in action are the unit test cases under the tests folder in the PySNMP GitHub repository.

If you find any issues with the examples, please report them to the current PySNMP maintainers.

Visit Support Options for more information.

SNMP is not simple (PySNMP implementation takes over 15K lines of Python code), but PySNMP tries to hide the complexities and let you carry out typical SNMP operations in a quick and intuitive way.

PySNMP offers high and low-level programming interfaces to deal with SNMP protocol.

The other dimension of differences in the PySNMP APIs is that there are two different SNMP implementations - the initial architecture (RFC1901 .. RFC1905) also known as SNMP v1 architecture and the redesigned variant (RFC3413 and others) – SNMPv3 architecture.

Note

The SNMP v1 architecture supports SNMP protocol versions 1 and 2c, while SNMP v3 architecture supports versions 1, 2c and 3. Whatever new amendments to the SNMP protocol may come up in the future, they will be implemented within the v3 model.

High-level SNMP

The high-level API (hlapi) is designed to be simple, concise and suitable for the most typical client-side operations. For that matter, only Command Generator and Notification Originator Applications are wrapped into a nearly one-line Python expression.

The hlapi interfaces used to come in several flavours: one synchronous and a bunch of asynchronous, adapted to work withing the event loops of popular asynchronous I/O frameworks. But now only asyncio based API is supported.

The primary reason for maintaining high-level API over both v1arch and v3arch is performance - v3arch machinery is much more functional and complicated internally, that translates to being heavier on resources and therefore slower.

The v3 architecture

• Asynchronous SNMP (asynio, v3arch)
  • Various SNMP versions
  • Walking operations
  • Advanced Command Generator
  • Common notifications
  • Advanced Notification Originator

The v1 architecture

• Asynchronous SNMP (asynio, v1arch)
  • Various SNMP versions
  • Walking operations
  • Advanced Command Generator
  • Common notifications
  • Advanced Notification Originator

Low-level v3 architecture

Complete implementation of all official Standard SNMP Applications. It should let you implement any SNMP operation defined in the standard at the cost of working at a somewhat low level.

This API also used to come in several transport varieties depending on I/O framework being used. But now only asyncio based API is supported.

• Asynchronous SNMP (asyncio, v3arch)
  • Command Responder Applications
  • Notification Receiver Applications

Low-level v1 architecture

In cases where performance is your top priority and you only need to work with SNMP v1 and v2c systems and you do not mind writing much more code, then there is a low-level API to SNMP v1/v2c PDU and PySNMP I/O engine. There’s practically no SNMP engine or SMI infrastructure involved in the operations of these almost wire-level interfaces. Although MIB services can still be used separately.

A packet-level API-based application typically manages both SNMP message building/parsing and network communication via one or more transports. It’s fully up to the application to handle failures on message and transport levels.

Command Generator

If you are developing an SNMP manager application, you will most likely want to study the following examples and learn how to send out SNMP requests.

• Fetching variables
  • Fetch scalar MIB variables (SNMPv1)
• Modifying variables
  • SET string and integer scalars (SNMPv2c)
• MIB walking operations
  • Walk Agent MIB (SNMPv1)
  • Bulk walk Agent MIB (SNMPv2c)
• Transport tweaks
  • Broadcast SNMP message (IPv4)

Command Responder

If you are developing an SNMP agent application, you will most likely want to study the following examples and learn how to respond to SNMP requests.

• Agent-side MIB implementations
  • Implementing scalar MIB objects

Notification Originator

These examples demonstrate how to send SNMP notifications, usually from an SNMP agent application.

• Transport tweaks
  • TRAP over multiple transports
  • INFORM over multiple transports

Notification Receiver

These examples demonstrate how to receive SNMP notifications, usually in an SNMP manager application.

• Transport tweaks
  • Listen for notifications at IPv4 & IPv6 interfaces

Low Level MIB Access

Accessing MIB objects is a common task in SNMP applications, so the following examples demonstrate how to do that.

• Manager side
  • PDU var-binds to MIB objects
  • MIB objects to PDU var-binds
  • SNMP MIB browser
• Agent side
  • Implementing MIB objects
  • Agent operations on MIB

Using these examples

Note

It is difficult to cover all examples on this site, so you might want to visit the examples folder in PySNMP GitHub repository.

When examples are not enough or out-of-date, you might want to refer to the latest unit test cases under the tests folder in the PySNMP GitHub repository. They are the most reliable resources to see the API in action.

Before using the sample code, make sure pysnmp and its dependencies are installed. You might refer to Quick Start for details.

Many sample scripts use the public, multilingual SNMP Command Responder and Notification Receiver configured at demo.pysnmp.com, which enable you to run them in a cut&paste fashion.

If you wish to use your own SNMP Agent with these scripts, make sure to either configure your local snmpd and/or snmptrapd, or use a valid address and SNMP credentials of your SNMP Agent in the examples to let them work.

Should you want to use a MIB to make SNMP operations more human-friendly, you are welcome to search for it and possibly download one from our public MIB repository mibs.pysnmp.com. Alternatively, you can configure PySNMP to fetch and cache required MIBs from there automatically.