GCP on localhost:4588

# pip install google-cloud-pubsub
import os
from google.api_core.exceptions import AlreadyExists
from google.cloud import pubsub_v1

os.environ["PUBSUB_EMULATOR_HOST"] = "localhost:4588"
project = "floci-local"

publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()

# create topic and subscription
topic = publisher.topic_path(project, "my-topic")
sub = subscriber.subscription_path(project, "my-sub")
try:
    publisher.create_topic(request={"name": topic})
    subscriber.create_subscription(
        request={"name": sub, "topic": topic}
    )
except AlreadyExists:
    pass  # already created on an earlier run

# publish a message
future = publisher.publish(topic, b"hello from floci-gcp!")
print("Published: " + str(future.result()))

# pull and acknowledge
resp = subscriber.pull(
    request={"subscription": sub, "max_messages": 1}
)
for msg in resp.received_messages:
    print(msg.message.data.decode())
    subscriber.acknowledge(
        request={"subscription": sub,
                 "ack_ids": [msg.ack_id]}
    )

// npm install @google-cloud/pubsub
process.env.PUBSUB_EMULATOR_HOST = 'localhost:4588';
const { PubSub } = require('@google-cloud/pubsub');
const pubsub = new PubSub({ projectId: 'floci-local' });

async function run() {
  const [topic] = await pubsub
    .topic('my-topic').get({ autoCreate: true });
  const [sub] = await topic
    .subscription('my-sub').get({ autoCreate: true });

  // publish a message
  const msgId = await topic.publishMessage({
    data: Buffer.from('hello from floci-gcp!'),
  });
  console.log('Published: ' + msgId);

  // receive one message
  sub.on('message', msg => {
    console.log(msg.data.toString());
    msg.ack();
    sub.removeAllListeners();
  });
}
run();

# pip install google-cloud-firestore
import os
from google.cloud import firestore

os.environ["FIRESTORE_EMULATOR_HOST"] = "localhost:4588"
db = firestore.Client(project="floci-local")

# write a document
ref = db.collection("users").document("alice")
ref.set({"name": "Alice", "score": 42})

# read it back
doc = ref.get()
print(doc.to_dict())

# query with a filter
for doc in (
    db.collection("users")
      .where("score", ">=", 40)
      .stream()
):
    print(doc.id, doc.to_dict())

// npm install @google-cloud/firestore
process.env.FIRESTORE_EMULATOR_HOST = 'localhost:4588';
const { Firestore } = require('@google-cloud/firestore');
const db = new Firestore({ projectId: 'floci-local' });

async function run() {
  // write a document
  const ref = db.collection('users').doc('alice');
  await ref.set({
    name: 'Alice', score: 42, active: true
  });

  // read it back
  const doc = await ref.get();
  console.log(doc.data());

  // query with a filter
  const snap = await db.collection('users')
    .where('score', '>=', 40).get();
  snap.forEach(d => console.log(d.id, d.data()));
}
run();

# pip install google-cloud-secret-manager
import grpc
from google.api_core.exceptions import AlreadyExists
from google.cloud import secretmanager
from google.cloud.secretmanager_v1.services.secret_manager_service.transports.grpc import (
    SecretManagerServiceGrpcTransport,
)

# the Python client ignores *_EMULATOR_HOST, so point it at floci-gcp over plain gRPC
transport = SecretManagerServiceGrpcTransport(
    channel=grpc.insecure_channel("localhost:4588")
)
client = secretmanager.SecretManagerServiceClient(transport=transport)
parent = "projects/floci-local"

# create the secret (skipped if it exists)
name = parent + "/secrets/db-password"
try:
    client.create_secret(request={
        "parent": parent,
        "secret_id": "db-password",
        "secret": {"replication": {"automatic": {}}},
    })
except AlreadyExists:
    pass

# store the value
client.add_secret_version(request={
    "parent": name,
    "payload": {"data": b"super-secret-value"},
})

# read the latest version
version = name + "/versions/latest"
resp = client.access_secret_version(request={"name": version})
print(resp.payload.data.decode())

# point gcloud at floci-gcp (any token works locally)
export CLOUDSDK_API_ENDPOINT_OVERRIDES_SECRETMANAGER=http://localhost:4588/
export CLOUDSDK_CORE_PROJECT=floci-local
export CLOUDSDK_AUTH_ACCESS_TOKEN=floci

# gcloud can't add secret versions on floci-gcp yet: store them from a
# client library (left), then read and list them here
gcloud secrets list

# read the latest version
gcloud secrets versions access latest \
  --secret db-password