LaunchFlow Logo

Compute Engine Resources

Resources for Google Cloud Compute Engine. Available resources include:

Example Usage

Create a VM running a Postgres instance

1
from sqlalchemy import text

2
import launchflow as lf

3


4
postgres_compute_engine = lf.gcp.ComputeEnginePostgres("ce-postgres-mn-test-2")

5
engine = postgres_compute_engine.sqlalchemy_engine()

6


7
with engine.connect() as connection:

8
    print(connection.execute(text("SELECT 1")).fetchone())  # prints (1,)

Create a VM running a Redis instance

1
import launchflow as lf

2


3
redis = lf.gcp.ComputeEngineRedis("my-redis-instance")

4


5
# Set a key-value pair

6
client = redis.redis()

7
client.set("my-key", "my-value")

8


9
# Async compatible

10
async_client = await redis.redis_async()

11
await async_client.set("my-key", "my-value")

ComputeEngine

A Compute Engine VM running a Docker container.

Like all Resources, this class configures itself across multiple Environments.

For more information see the official documentation.

Example Usage

1
import launchflow as lf

2


3
# Automatically creates / connects to a Compute Engine VM with a provided Docker image

4
compute_engine = lf.gcp.ComputeEngine("my-compute-engine", vm_config=lf.gcp.compute_engine.VMConfig(

5
    additional_outputs={"my_output": "my_value"},

6
    docker_cfg=lf.gcp.compute_engine.DockerConfig(

7
        image="my-docker-image",

8
        args=[],

9
        environment_variables=[lf.gcp.compute_engine.EnvironmentVariable("MY_ENV_VAR": "my_value")],

10
    ),

11
    firewall_cfg=lf.gcp.compute_engine.FirewallConfig(expose_ports=[80]),

12
))

initialization

Create a Compute Engine resource.

Args:

  • name (str): The name of the resource. This must be globally unique.
  • vm_config (VMConfig): The configuration for the VM.
    • additional_outputs (dict): Additional outputs to be returned by the resource.
    • docker_cfg (DockerConfig): The configuration for the Docker container.
      • image (str): The Docker image to run.
      • args (List[str]): The arguments to pass to the Docker container.
      • environment_variables (List[EnvironmentVariable]): Environment variables to set in the Docker container.
    • firewall_cfg (FirewallConfig): The configuration for the firewall rules.
      • expose_ports (List[int]): The ports to expose in the firewall.

inputs

1
ComputeEngine.inputs(environment_state: EnvironmentState) -> VMConfig

Get the inputs for the Compute Engine VM resource.

Args:

  • environment_state (EnvironmentState): The environment to get inputs for

Returns:

  • VMConfig: The inputs for the Compute Engine VM resource.

ComputeEnginePostgres

A Postgres instance running on a VM in Google Compute Engine.

Example usage

1
from sqlalchemy import text

2
import launchflow as lf

3


4
postgres_compute_engine = lf.gcp.ComputeEnginePostgres("ce-postgres-mn-test-2")

5
engine = postgres_compute_engine.sqlalchemy_engine()

6


7
with engine.connect() as connection:

8
    print(connection.execute(text("SELECT 1")).fetchone())  # prints (1,)

initialization

Create a new Compute Engine Postgres resource.

Args:

  • name (str): The name of the Postgres VM resource. This must be globally unique.
  • password (str): The password for the Postgres DB. If not provided, a random password will be generated.

inputs

1
ComputeEnginePostgres.inputs(environment_state: EnvironmentState) -> VMConfig

Get the inputs for the Compute Engine Postgres resource.

Args:

  • environment_state (EnvironmentState): The environment to get inputs for

Returns:

  • VMConfig: The inputs for the Compute Engine Postgres resource.

query

1
ComputeEnginePostgres.query(query: str)

Executes a SQL query on the Postgres instance running on the Compute Engine VM.

Args:

  • query (str): The SQL query to execute.

Returns:

  • The results of the query.

Example usage:

1
import launchflow as lf

2


3
postgres = lf.gcp.ComputeEnginePostgres("my-pg-db")

4


5
# Executes a query on the Postgres instance running on the Compute Engine VM

6
postgres.query("SELECT 1")

NOTE: This method is not recommended for production use. Use sqlalchemy_engine instead.

django_settings

1
ComputeEnginePostgres.django_settings()

Returns a Django settings dictionary for connecting to the Postgres instance running on the Compute Engine VM.

Returns:

  • A dictionary of Django settings for connecting to the Postgres instance.

Example usage:

1
import launchflow as lf

2


3
postgres = lf.gcp.ComputeEnginePostgres("my-pg-db")

4


5
# settings.py

6
DATABASES = {

7
    # Connect Django's ORM to the Postgres instance running on the Compute Engine VM

8
    "default": postgres.django_settings(),

9
}

sqlalchemy_engine_options

1
ComputeEnginePostgres.sqlalchemy_engine_options()

Returns the SQLAlchemy engine options for connecting to the Postgres instance running on the Compute Engine VM.

Returns:

  • A dictionary of SQLAlchemy engine options for connecting to the Postgres instance.

sqlalchemy_async_engine_options

1
async ComputeEnginePostgres.sqlalchemy_async_engine_options()

Returns the async SQLAlchemy engine options for connecting to the Postgres instance running on the Compute Engine VM.

Returns:

  • A dictionary of async SQLAlchemy engine options for connecting to the Postgres instance.

sqlalchemy_engine

1
ComputeEnginePostgres.sqlalchemy_engine(**engine_kwargs)

Returns a SQLAlchemy engine for connecting to a Postgres instance hosted on GCP compute engine.

Args:

  • **engine_kwargs: Additional keyword arguments to pass to sqlalchemy.create_engine.

Returns:

  • The SQLAlchemy engine.

Example usage:

1
import launchflow as lf

2
db = lf.gcp.ComputeEnginePostgres("my-pg-db")

3
engine = db.sqlalchemy_engine()

sqlalchemy_async_engine

1
async ComputeEnginePostgres.sqlalchemy_async_engine(**engine_kwargs)

Returns an async SQLAlchemy engine for connecting to a Postgres instance hosted on GCP compute engine.

Args:

  • **engine_kwargs: Additional keyword arguments to pass to create_async_engine.

Returns:

  • The async SQLAlchemy engine.

Example usage:

1
import launchflow as lf

2
db = lf.gcp.ComputeEnginePostgres("my-pg-db")

3
engine = await db.sqlalchemy_async_engine()

ComputeEngineRedis

A Redis instance running on a VM in Google Compute Engine.

Example usage

1
import launchflow as lf

2


3
redis = lf.gcp.ComputeEngineRedis("my-redis-instance")

4


5
# Set a key-value pair

6
client = redis.redis()

7
client.set("my-key", "my-value")

8


9
# Async compatible

10
async_client = await redis.redis_async()

11
await async_client.set("my-key", "my-value")

initialization

Create a new Compute Engine Redis resource.

Args:

  • name (str): The name of the Redis VM resource. This must be globally unique.
  • password (str): The password for the Redis DB. If not provided, a random password will be generated.

inputs

1
ComputeEngineRedis.inputs(environment_state: EnvironmentState) -> VMConfig

Get the inputs for the Compute Engine Redis resource.

Args:

  • environment_state (EnvironmentState): The environment to get inputs for

Returns:

  • VMConfig: The inputs for the Compute Engine Redis resource.

django_settings

1
ComputeEngineRedis.django_settings()

Returns a Django settings dictionary for connecting to the Redis instance running on the Compute Engine VM.

Returns:

  • A dictionary of Django settings for connecting to the Redis instance.

Example usage:

1
import launchflow as lf

2


3
redis = lf.gcp.ComputeEngineRedis("my-redis-instance")

4


5
# settings.py

6
CACHES = {

7
    # Connect Django's cache to the Redis instance running on the Compute Engine VM

8
    "default": redis.django_settings(),

9
}

redis

1
ComputeEngineRedis.redis(*, decode_responses: bool = True)

Get a Generic Redis Client object from the redis-py library.

Args:

  • decode_responses (bool): Whether to decode responses from the Redis server. Defaults to True.

Returns:

redis_async

1
async ComputeEngineRedis.redis_async(*, decode_responses: bool = True)

Get an Async Redis Client object from the redis-py library.

Args:

  • decode_responses (bool): Whether to decode responses from the Redis server. Defaults to True.

Returns: