最終更新日 2024年04月30日(火)

Heroku Data for Redis には、Heroku によってサポートされているすべての言語およびフレームワークを含むすべての言語から、Redis ドライバーでアクセスできます。また、独自の環境で実行されているクライアントから、Mini プランまたは Premium プランでホストされている Heroku Data for Redis にアクセスすることもできます。

接続のアクセス許可

すべての Heroku Data for Redis ユーザーに、Redis 内のすべてのコマンド​ (CONFIG​、SHUTDOWN​、BGREWRITEAOF​、BGSAVE​、SAVE​、MOVE​、MODULE​、MIGRATE​、SLAVEOF​、REPLICAOF​、ACL​、DEBUG​ を除く) へのアクセス許可が付与されます。

外部接続

Heroku ランタイムから使用できることに加えて、Heroku Data for Redis の Mini プランと Premium プランのインスタンスには、ローカルコンピューターやその他の場所で実行されているクライアントからアクセスできます。

外部システムまたはクライアントから接続するには、次のいずれかの方法を使用して Redis 接続文字列を取得します。

• heroku redis:credentials​ CLI コマンドを実行する (詳細は、「redis:credentials)​」を参照)。
• コマンド heroku config:get REDIS_URL -a example-app​ を実行して、アプリの環境設定を検査する

Java での接続

Heroku Data for Redis に接続するにはさまざまな方法がありますが、個々の方法は使用中の Java フレームワークに依存します。すべての接続方法では REDIS_URL​ 環境変数を使用して接続情報を調べます。

Spring Boot

Spring Boot の Redis に対するサポートでは、REDIS_URL​ などのすべての Redis 設定が自動的に選択されます。TLS ピアの確認を無効にするには、LettuceClientConfigurationBuilderCustomizer​ Bean を定義します。

@Configuration
class AppConfig {

    @Bean
    public LettuceClientConfigurationBuilderCustomizer lettuceClientConfigurationBuilderCustomizer() {
        return clientConfigurationBuilder -> {
            if (clientConfigurationBuilder.build().isUseSsl()) {
                clientConfigurationBuilder.useSsl().disablePeerVerification();
            }
        };
    }
}

Lettuce

このスニペットでは、REDIS_URL​ 環境変数を使用して、Lettuce​ を経由した Redis への接続を作成します。StatefulRedisConnection​はスレッドセーフであるため、マルチスレッド環境で安全に使用できます。

 public static StatefulRedisConnection<String, String> connect() {
    RedisURI redisURI = RedisURI.create(System.getenv("REDIS_URL"));
    redisURI.setVerifyPeer(false);

    RedisClient redisClient = RedisClient.create(redisURI);
    return redisClient.connect();
}

Jedis

このスニペットでは、REDIS_URL​ 環境変数を使用して URI を作成します。この新しい URI は、Jedis​ を経由した Redis への接続を作成するために使用されます。この例では、Redis への 1 つの接続を作成します。

private static Jedis getConnection() {
    try {
        TrustManager bogusTrustManager = new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }

            public void checkClientTrusted(X509Certificate[] certs, String authType) {
            }

            public void checkServerTrusted(X509Certificate[] certs, String authType) {
            }
        };

        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, new TrustManager[]{bogusTrustManager}, new java.security.SecureRandom());

        HostnameVerifier bogusHostnameVerifier = (hostname, session) -> true;

        return new Jedis(URI.create(System.getenv("REDIS_URL")),
                sslContext.getSocketFactory(),
                sslContext.getDefaultSSLParameters(),
                bogusHostnameVerifier);

    } catch (NoSuchAlgorithmException | KeyManagementException e) {
        throw new RuntimeException("Cannot obtain Redis connection!", e);
    }
}

マルチスレッド環境 (Web サーバーなど) で Jedis を実行している場合は、同じ Jedis インスタンスを使用して Redis を操作しないでください。そうではなく、Jedis Pool を作成して、アプリケーションコードが Redis 接続をチェックアウトし、操作が終了したら接続をプールに返すようにしてください。

// The assumption with this method is that it's been called when the application
// is booting up so that a static pool has been created for all threads to use.
// e.g. pool = getPool()
public static JedisPool getPool() {
    try {
        TrustManager bogusTrustManager = new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }

            public void checkClientTrusted(X509Certificate[] certs, String authType) {
            }

            public void checkServerTrusted(X509Certificate[] certs, String authType) {
            }
        };

        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, new TrustManager[]{bogusTrustManager}, new java.security.SecureRandom());

        HostnameVerifier bogusHostnameVerifier = (hostname, session) -> true;

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(10);
        poolConfig.setMaxIdle(5);
        poolConfig.setMinIdle(1);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(true);

        return new JedisPool(poolConfig,
                URI.create(System.getenv("REDIS_URL")),
                sslContext.getSocketFactory(),
                sslContext.getDefaultSSLParameters(),
                bogusHostnameVerifier);

    } catch (NoSuchAlgorithmException | KeyManagementException e) {
        throw new RuntimeException("Cannot obtain Redis connection!", e);
    }
}

// In your multithreaded code this is where you'd checkout a connection
// and then return it to the pool
try (Jedis jedis = pool.getResource()){
  jedis.set("foo", "bar");
}

Ruby での接続

Ruby アプリケーションで Redis を使用するには、Gemfile​ に redis​ gem を含める必要があります。

gem 'redis'

bundle install​ を実行して、すべての依存関係をダウンロードして解決します。

Rails での接続

次のコードを含む config/initializers/redis.rb​ という名前のイニシャライザファイルを作成します。

$redis = Redis.new(url: ENV["REDIS_URL"], ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE })

Sidekiq からの接続

次のコードを含む config/initializers/sidekiq.rb​ という名前のイニシャライザファイルを作成します。

Sidekiq.configure_server do |config|
  config.redis = {
    url: ENV["REDIS_URL"],
    ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }
  }
end

Sidekiq.configure_client do |config|
  config.redis = {
      url: ENV["REDIS_URL"],
      ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }
  }
end

Python での接続

Python アプリケーションで Redis を使用するには、redis​ パッケージを使用します。

$ pip install redis
$ pip freeze > requirements.txt

コード内でこのパッケージを使用して REDIS_URL​ に接続します。

import os
import redis

r = redis.from_url(os.environ.get("REDIS_URL"))

Redis に TLS が必要な場合、ssl_cert_reqs​ を設定して証明書の検証を無効化します。

import os
from urllib.parse import urlparse
import redis

url = urlparse(os.environ.get("REDIS_URL"))
r = redis.Redis(host=url.hostname, port=url.port, password=url.password, ssl=True, ssl_cert_reqs=None)

Django での接続

4.0 よりも前の Django バージョンを実行している場合、Django アプリケーションで Redis を使用するには、django-redis​ を使用します。

Django バージョン 4.0 以降を実行している場合は、django-redis または Django 4.0 で導入された組み込みの Redis バックエンドサポート​を使用できます。

django-redis の使用

django-redis​ モジュールをインストールします。

$ pip install django-redis
$ pip freeze > requirements.txt

settings.py​ で、django_redis.cache.RedisCache​ を CACHES​ の BACKEND​ として設定します。

import os

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": os.environ.get('REDIS_URL'),
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

Redis に TLS が必要な場合、ssl_cert_reqs​ を設定して証明書の検証を無効化します。

import os

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": os.environ.get('REDIS_URL'),
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {
                "ssl_cert_reqs": None
            },
        }
    }
}

組み込みの Redis バックエンドサポートの使用

Django の組み込み Redis バックエンドサポートには、redis-py​ 3.0.0 以降が必要です。

settings.py​ で、django.core.cache.backends.redis.RedisCache​ を CACHES​ の BACKEND​ として設定します。

import os

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": os.environ.get('REDIS_URL')
    }
}

Redis に TLS が必要な場合、ssl_cert_reqs​ を設定して証明書の検証を無効化します。

import os

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": os.environ.get('REDIS_URL'),
        "OPTIONS": {
                "ssl_cert_reqs": None
        }
    }
}

Node.js での接続

redis モジュール

redis​ NPM モジュールを依存関係に追加します。

npm install redis

このモジュールを使用して REDIS_URL​ に接続します。

const redis = require("redis");
const client = redis.createClient({url: process.env.REDIS_URL});

さらに、TLS を使用するように redis​ を設定できます。Node.js Redis バージョン 4.0.0 以降を使用している場合は、次のコードを使用して TLS に接続します。

const redis = require("redis");

const client = redis.createClient({
  url: process.env.REDIS_URL,
  socket: {
    tls: true,
    rejectUnauthorized: false,
  }
});

Node.js Redis バージョン 3.1.2 以前を使用している場合は、次のコードを使用して TLS に接続します。

const redis = require("redis");

const client = redis.createClient({
  url: process.env.REDIS_URL,
  tls: {
    rejectUnauthorized: false
  }
});

ioredis モジュール

ioredis​ NPM モジュールを依存関係に追加します。

npm install ioredis

そして、このモジュールを使用して REDIS_URL​ に接続します。

const Redis = require("ioredis");
const client = new Redis(process.env.REDIS_URL);

TLS を使用してクライアントを設定する場合は、次を使用できます。

const Redis = require("ioredis");

const client = new Redis(process.env.REDIS_URL, {
    tls: {
        rejectUnauthorized: false
    }
});

PHP での接続

Redis 拡張機能を使用した接続

composer.json​ 内の要件に ext-redis​ を追加します。

"require": {
  …
  "ext-redis": "*",
  …
}

環境の REDIS_URL​ 環境設定を解析した後、Redis に接続します。

$url = parse_url(getenv("REDIS_URL"));
$redis = new Redis();
$redis->connect("tls://".$url["host"], $url["port"], 0, NULL, 0, 0, [
  "auth" => $url["pass"],
  "stream" => ["verify_peer" => false, "verify_peer_name" => false],
]);

Predis を使用した接続

composer.json​ で、predis​ パッケージを要件に追加します。

"require": {
  ...
  "predis/predis": "^1.1",
  ...
}

環境の REDIS_URL​ 環境設定を使用して Redis に接続します。

$redis = new Predis\Client(getenv('REDIS_URL') . "?ssl[verify_peer_name]=0&ssl[verify_peer]=0");

Go での接続

アプリケーションに go-redis​ パッケージを追加します。

$ go get github.com/redis/go-redis/v9

パッケージをインポートします。

import "github.com/redis/go-redis/v9"

REDIS_URL​ 設定変数を使用して Redis に接続します。

uri := os.Getenv("REDIS_URL")
opts, err := redis.ParseURL(uri)
if err != nil {
    // Handle error
}

if strings.HasPrefix(uri, "rediss") {
    opts.TLSConfig = &tls.Config{
        InsecureSkipVerify: true,
    }
}
rdb := redis.NewClient(opts)