DEV Community: Alex Friedman

Sorting by external keys in Redis with Python

Alex Friedman — Wed, 21 Oct 2020 21:11:43 +0000

Sometimes you want to sort elements using external keys as weights to compare instead of comparing the actual elements in the list, set or sorted set. Let's say the list indices contains the elements key0, key1, and key3 representing unique IDs of objects stored in as key0, key1, and key3. When these objects have associated weights stored in their hash, SORT can be instructed to use these weights to sort indices.

>>> from random import randint
>>> import redis
>>> r = redis.Redis(host='localhost', port=6379)

>>> for i in range(3):
...     key = f'key{i}'
...     r.hset(key, 'weight', randint(0, 100))
...     r.sadd('indices', key)

>>> # Show the weights of each Hash
>>> [(f'key{i}', r.hget(f'key{i}', 'weight')) for i in range(3)]
[('key0', b'91'), ('key1', b'40'), ('key2', b'63')]

>>> r.sort('indices', by='*->weight')
[b'key1', b'key2', b'key0']

Atomically popping multiple items from a Redis list in Python

Alex Friedman — Wed, 14 Oct 2020 00:10:17 +0000

What are we doing?

We're trying to atomically pop and remove multiple items from a list in Redis.

What?

Consider a list: 0 1 2 3 4 5
I want to return the results of the first 3 items and then remove those items. I also need to guarantee that the list does not change in the time between returning the results and remove the results from the list.

An example

Consider this example:

> RPUSH mykey 0 1 2 3 4 5
(integer) 6
> LRANGE mykey 0 2
1) "0"
2) "1"
3) "2"
> LTRIM mykey 3 -1
OK
> LRANGE mykey 0 99
1) "3"
2) "4"
3) "5"

This works well if you are the only one manipulating your list. But what if somebody else is manipulating the list at the same time?

> RPUSH mykey 0 1 2 3 4 5
(integer) 6
> LRANGE mykey 0 2
1) "0"
2) "1"
3) "2"
> LTRIM mykey 3 -1
OK
> LRANGE mykey 0 99
(empty array)

Uh-oh. Another consumer, who we will call B, ran LRANGE mykey 0 2 and received 0 1 2. We ran the same command immediately after them and received the same results. Consumer B now runs LTRIM mykey 3 -1, and we do too. Now the list is empty, but both consumers only received the first 3 items of the list. The final 3 are gone.

Solution

I need these two transactions, LRANGE and LTRIM, to be atomic. That means that either they both execute, or neither does. In Redis, we can achieve this using transactions. All the commands in a transaction are serialized and executed sequentially. It can never happen that a request issued by another client is served in the middle of the execution of a Redis transaction. This guarantees that the commands are executed as a single isolated operation.

If you were using the Redis CLI, you would alter your code to look like this:

> MULTI
OK
> RPUSH mykey 0 1 2 3 4 5
QUEUED
> LTRIM mykey 3 -1
QUEUED
> EXEC
1) (integer) 6
2) OK

In Python

Since nobody actually uses CLIs, let's do this in Python. This script uses redis-py's Pipeline feature. Pipelines are a subclass of the base Redis class that provide support for buffering multiple commands to the server in a single request.

>>> import redis
>>> my_key = 'pop_trim_test'
>>> r = redis.Redis(host='localhost', port=6379)
>>> r.rpush(my_key, *[x for x in range(10)])
>>> pipe = r.pipeline()
>>> pipe.lrange(my_key, 0, 3)
>>> pipe.ltrim(my_key, 4, -1)
>>> pipe.execute()
[[b'0', b'1', b'2', b'3'], True]

pipe.execute() sequentially returns the results of your pipe commands as a list. Therefore, the results of our lrange are the first item in the list.

Even better

If you're working with a consumer model where applications wait for items in a queue, the above code can be problematic because it is constantly querying Redis. A better behavior is to use Redis' blocking pop (BLPOP) function. With BLPOP, if the key is empty, the client blocks the connection until another client performs an LPUSH or RPUSH operation against the key. It's a great resource for handling multiple consumers. You can work this in by running the above code after the consumer successfully executes a BLPOP.

Discover pods by label in Prometheus

Alex Friedman — Mon, 12 Oct 2020 18:00:54 +0000

What are we doing?

Kubernetes SD configurations allow retrieving scrape targets from Kubernetes' REST API in order to stay synchronized with the cluster state.

I created an image of a Python program that exports metrics using the the Prometheus Python client. Setting the environment variable EXPORTER_PORT will publish metrics to that port.

I deployed this container in pods with labels foo and bar and sent metrics to port 9000 and 8000 respectively. You can see in the below Prometheus config that I target them separately by their label name.

Why would you need to do this?

I found a case where I wanted different scrape configurations per pod in my cluster. Usually, I can set the kubernetes_sd_configs role to service, which discovers a target for each service port for each service (see the docs). However, in this case I had different collection requirements for the pods inside my k8s abstractions.

Example config files

Foo Deployment



apiVersion: apps/v1
kind: Deployment
metadata:
  name: foo-deployment
  labels:
    app: foo
spec:
  selector:
    matchLabels:
      app: foo
  replicas: 2
  template:
    metadata:
      labels:
        app: foo
    spec:
      containers:
      - name: python-prometheus-exporter-example
        image: ahf90/python-prometheus-exporter-example
        imagePullPolicy: Always
        ports:
          - containerPort: 9000
        env:
          - name: EXPORTER_PORT
            value: '9000'

Bar Deployment



apiVersion: apps/v1
kind: Deployment
metadata:
  name: bar-deployment
  labels:
    app: bar
spec:
  selector:
    matchLabels:
      app: bar
  replicas: 2
  template:
    metadata:
      labels:
        app: bar
    spec:
      containers:
      - name: python-prometheus-exporter-example
        image: ahf90/python-prometheus-exporter-example
        imagePullPolicy: Always
        ports:
          - containerPort: 8000
        env:
          - name: EXPORTER_PORT
            value: '8000'

Prometheus config.yml



scrape_configs:
  - job_name: 'prometheus'
    static_configs:
    - targets: ['localhost:9090']
  - job_name: 'foo-targets'
    scrape_interval: 10s
    metrics_path: '/'
    kubernetes_sd_configs:
    - role: pod
      namespaces:
        names:
        - default
      selectors:
      - role: "pod"
        label: "app=foo"
  - job_name: 'bar-targets'
    scrape_interval: 5s
    metrics_path: '/'
    kubernetes_sd_configs:
      - role: pod
        namespaces:
          names:
            - default
        selectors:
          - role: "pod"
            label: "app=bar"