Lambda Labs GPU云：按需GPU实例与一键集群，专为AI/机器学习训练优化

lambda-labs-gpu-cloud by davila7/claude-code-templates

165 周安装量

23,400 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/davila7/claude-code-templates --skill lambda-labs-gpu-cloud

AI/机器学习云服务 PyTorch

🇨🇳中文介绍

Lambda Labs GPU 云

在 Lambda Labs GPU 云上运行机器学习工作负载的综合指南，涵盖按需实例和一键式集群。

何时使用 Lambda Labs

在以下情况下使用 Lambda Labs：

需要具有完全 SSH 访问权限的专用 GPU 实例
运行长时间的训练任务（数小时到数天）
希望获得简单定价且无出口费用
需要在会话之间保持持久存储
需要高性能多节点集群（16-512 个 GPU）
希望使用预安装的 ML 堆栈（包含 PyTorch、CUDA、NCCL 的 Lambda Stack）

主要特性：

GPU 种类多样：B200、H100、GH200、A100、A10、A6000、V100
Lambda Stack：预安装 PyTorch、TensorFlow、CUDA、cuDNN、NCCL
持久文件系统：在实例重启后保留数据
一键式集群：配备 InfiniBand 的 16-512 GPU Slurm 集群
简单定价：按分钟计费，无出口费用
全球区域：全球 12 个以上区域

使用替代方案的情况：

Modal：适用于无服务器、自动扩展的工作负载
SkyPilot：适用于多云编排和成本优化
RunPod：适用于更便宜的竞价实例和无服务器端点
Vast.ai：适用于价格最低的 GPU 市场

快速开始

账户设置

在 https://lambda.ai 创建账户

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

通过控制台启动

访问 https://cloud.lambda.ai/instances
点击"启动实例"
选择 GPU 类型和区域
选择 SSH 密钥
（可选）附加文件系统
启动并等待 3-15 分钟

# 从控制台获取实例 IP
ssh ubuntu@<INSTANCE-IP>

# 或使用特定密钥
ssh -i ~/.ssh/lambda_key ubuntu@<INSTANCE-IP>

GPU	显存	价格/GPU/小时	最适合
B200 SXM6	180 GB	$4.99	最大模型，最快训练
H100 SXM	80 GB	$2.99-3.29	大型模型训练
H100 PCIe	80 GB	$2.49	性价比高的 H100
GH200	96 GB	$1.49	单 GPU 大型模型
A100 80GB	80 GB	$1.79	生产训练
A100 40GB	40 GB	$1.29	标准训练
A10	24 GB	$0.75	推理，微调
A6000	48 GB	$0.80	良好的显存/价格比
V100	16 GB	$0.55	预算训练

8x GPU: 最适合分布式训练 (DDP, FSDP)
4x GPU: 大型模型，多 GPU 训练
2x GPU: 中等规模工作负载
1x GPU: 微调，推理，开发

单 GPU：3-5 分钟
多 GPU：10-15 分钟

所有实例均预装 Lambda Stack：

# 包含的软件
- Ubuntu 22.04 LTS
- NVIDIA 驱动程序（最新）
- CUDA 12.x
- cuDNN 8.x
- NCCL（用于多 GPU）
- PyTorch（最新）
- TensorFlow（最新）
- JAX
- JupyterLab

# 检查 GPU
nvidia-smi

# 检查 PyTorch
python -c "import torch; print(torch.cuda.is_available())"

# 检查 CUDA 版本
nvcc --version

pip install lambda-cloud-client

import os
import lambda_cloud_client

# 使用 API 密钥配置
configuration = lambda_cloud_client.Configuration(
    host="https://cloud.lambdalabs.com/api/v1",
    access_token=os.environ["LAMBDA_API_KEY"]
)

with lambda_cloud_client.ApiClient(configuration) as api_client:
    api = lambda_cloud_client.DefaultApi(api_client)

    # 获取可用实例类型
    types = api.instance_types()
    for name, info in types.data.items():
        print(f"{name}: {info.instance_type.description}")

from lambda_cloud_client.models import LaunchInstanceRequest

request = LaunchInstanceRequest(
    region_name="us-west-1",
    instance_type_name="gpu_1x_h100_sxm5",
    ssh_key_names=["my-ssh-key"],
    file_system_names=["my-filesystem"],  # 可选
    name="training-job"
)

response = api.launch_instance(request)
instance_id = response.data.instance_ids[0]
print(f"Launched: {instance_id}")

列出运行中的实例

instances = api.list_instances()
for instance in instances.data:
    print(f"{instance.name}: {instance.ip} ({instance.status})")

from lambda_cloud_client.models import TerminateInstanceRequest

request = TerminateInstanceRequest(
    instance_ids=[instance_id]
)
api.terminate_instance(request)

from lambda_cloud_client.models import AddSshKeyRequest

# 添加 SSH 密钥
request = AddSshKeyRequest(
    name="my-key",
    public_key="ssh-rsa AAAA..."
)
api.add_ssh_key(request)

# 列出密钥
keys = api.list_ssh_keys()

# 删除密钥
api.delete_ssh_key(key_id)

curl -u $LAMBDA_API_KEY: \
  https://cloud.lambdalabs.com/api/v1/instance-types | jq

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/launch \
  -H "Content-Type: application/json" \
  -d '{
    "region_name": "us-west-1",
    "instance_type_name": "gpu_1x_h100_sxm5",
    "ssh_key_names": ["my-key"]
  }' | jq

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/terminate \
  -H "Content-Type: application/json" \
  -d '{"instance_ids": ["<INSTANCE-ID>"]}' | jq

文件系统在实例重启后保留数据：

# 挂载位置
/lambda/nfs/<FILESYSTEM_NAME>

# 示例：保存检查点
python train.py --checkpoint-dir /lambda/nfs/my-storage/checkpoints

在 Lambda 控制台中转到存储
点击"创建文件系统"
选择区域（必须与实例区域匹配）
命名并创建

文件系统必须在实例启动时附加：

通过控制台：启动时选择文件系统
通过 API：在启动请求中包含 file_system_names

# 存储在文件系统上（持久）
/lambda/nfs/storage/
  ├── datasets/
  ├── checkpoints/
  ├── models/
  └── outputs/

# 本地 SSD（更快，临时）
/home/ubuntu/
  └── working/  # 临时文件

# 本地生成密钥
ssh-keygen -t ed25519 -f ~/.ssh/lambda_key

# 将公钥添加到 Lambda 控制台
# 或通过 API

# 在实例上，添加更多密钥
echo 'ssh-rsa AAAA...' >> ~/.ssh/authorized_keys

# 在实例上
ssh-import-id gh:username

# 转发 Jupyter
ssh -L 8888:localhost:8888 ubuntu@<IP>

# 转发 TensorBoard
ssh -L 6006:localhost:6006 ubuntu@<IP>

# 多个端口
ssh -L 8888:localhost:8888 -L 6006:localhost:6006 ubuntu@<IP>

转到实例页面
在 Cloud IDE 列中点击"启动"
JupyterLab 在浏览器中打开

# 在实例上
jupyter lab --ip=0.0.0.0 --port=8888

# 从本地机器通过隧道
ssh -L 8888:localhost:8888 ubuntu@<IP>
# 打开 http://localhost:8888

# SSH 到实例
ssh ubuntu@<IP>

# 克隆仓库
git clone https://github.com/user/project
cd project

# 安装依赖
pip install -r requirements.txt

# 训练
python train.py --epochs 100 --checkpoint-dir /lambda/nfs/storage/checkpoints

多 GPU 训练（单节点）

# train_ddp.py
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

def main():
    dist.init_process_group("nccl")
    rank = dist.get_rank()
    device = rank % torch.cuda.device_count()

    model = MyModel().to(device)
    model = DDP(model, device_ids=[device])

    # Training loop...

if __name__ == "__main__":
    main()

# 使用 torchrun 启动（8 个 GPU）
torchrun --nproc_per_node=8 train_ddp.py

将检查点保存到文件系统

import os

checkpoint_dir = "/lambda/nfs/my-storage/checkpoints"
os.makedirs(checkpoint_dir, exist_ok=True)

# 保存检查点
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}, f"{checkpoint_dir}/checkpoint_{epoch}.pt")

高性能 Slurm 集群，包含：

16-512 个 NVIDIA H100 或 B200 GPU
NVIDIA Quantum-2 400 Gb/s InfiniBand
GPUDirect RDMA，速度达 3200 Gb/s
预安装的分布式 ML 堆栈

Ubuntu 22.04 LTS + Lambda Stack
NCCL, Open MPI
支持 DDP 和 FSDP 的 PyTorch
TensorFlow
OFED 驱动程序

每个计算节点 24 TB NVMe（临时）
Lambda 文件系统用于持久数据

# 在 Slurm 集群上
srun --nodes=4 --ntasks-per-node=8 --gpus-per-node=8 \
  torchrun --nnodes=4 --nproc_per_node=8 \
  --rdzv_backend=c10d --rdzv_endpoint=$MASTER_ADDR:29500 \
  train.py

实例间（同一区域）：最高 200 Gbps
互联网出站：最高 20 Gbps

默认：仅开放端口 22 (SSH)
在 Lambda 控制台中配置其他端口
默认允许 ICMP 流量

# 查找私有 IP
ip addr show | grep 'inet '

工作流 1：微调 LLM

# 1. 启动带文件系统的 8x H100 实例

# 2. SSH 并设置
ssh ubuntu@<IP>
pip install transformers accelerate peft

# 3. 将模型下载到文件系统
python -c "
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf')
model.save_pretrained('/lambda/nfs/storage/models/llama-2-7b')
"

# 4. 在文件系统上进行带检查点的微调
accelerate launch --num_processes 8 train.py \
  --model_path /lambda/nfs/storage/models/llama-2-7b \
  --output_dir /lambda/nfs/storage/outputs \
  --checkpoint_dir /lambda/nfs/storage/checkpoints

工作流 2：批量推理

# 1. 启动 A10 实例（推理性价比高）

# 2. 运行推理
python inference.py \
  --model /lambda/nfs/storage/models/fine-tuned \
  --input /lambda/nfs/storage/data/inputs.jsonl \
  --output /lambda/nfs/storage/data/outputs.jsonl

任务	推荐 GPU
LLM 微调 (7B)	A100 40GB
LLM 微调 (70B)	8x H100
推理	A10, A6000
开发	V100, A10
最大性能	B200

使用文件系统：避免重复下载数据
频繁保存检查点：恢复中断的训练
合理配置规模：不要过度配置 GPU
终止空闲实例：无自动停止，需手动终止

仪表板显示实时 GPU 利用率
API 用于编程监控

问题	解决方案
实例无法启动	检查区域可用性，尝试不同的 GPU
SSH 连接被拒绝	等待实例初始化（3-15 分钟）
终止后数据丢失	使用持久文件系统
数据传输缓慢	使用同一区域的文件系统
未检测到 GPU	重启实例，检查驱动程序

高级用法 - 多节点训练，API 自动化
故障排除 - 常见问题及解决方案

2026 年 1 月 21 日

🇺🇸English

Lambda Labs GPU Cloud

Comprehensive guide to running ML workloads on Lambda Labs GPU cloud with on-demand instances and 1-Click Clusters.

When to use Lambda Labs

Use Lambda Labs when:

Need dedicated GPU instances with full SSH access
Running long training jobs (hours to days)
Want simple pricing with no egress fees
Need persistent storage across sessions
Require high-performance multi-node clusters (16-512 GPUs)
Want pre-installed ML stack (Lambda Stack with PyTorch, CUDA, NCCL)

Key features:

GPU variety : B200, H100, GH200, A100, A10, A6000, V100
Lambda Stack : Pre-installed PyTorch, TensorFlow, CUDA, cuDNN, NCCL
Persistent filesystems : Keep data across instance restarts
1-Click Clusters : 16-512 GPU Slurm clusters with InfiniBand
Simple pricing : Pay-per-minute, no egress fees
Global regions : 12+ regions worldwide

Use alternatives instead:

Modal : For serverless, auto-scaling workloads
SkyPilot : For multi-cloud orchestration and cost optimization
RunPod : For cheaper spot instances and serverless endpoints
Vast.ai : For GPU marketplace with lowest prices

Quick start

Account setup

Create account at https://lambda.ai
Add payment method
Generate API key from dashboard
Add SSH key (required before launching instances)

Launch via console

Go to https://cloud.lambda.ai/instances
Click "Launch instance"
Select GPU type and region
Choose SSH key
Optionally attach filesystem
Launch and wait 3-15 minutes

Connect via SSH

# Get instance IP from console
ssh ubuntu@<INSTANCE-IP>

# Or with specific key
ssh -i ~/.ssh/lambda_key ubuntu@<INSTANCE-IP>

GPU instances

Available GPUs

GPU	VRAM	Price/GPU/hr	Best For
B200 SXM6	180 GB	$4.99	Largest models, fastest training
H100 SXM	80 GB	$2.99-3.29	Large model training
H100 PCIe	80 GB	$2.49	Cost-effective H100
GH200	96 GB	$1.49	Single-GPU large models
A100 80GB	80 GB	$1.79	Production training
A100 40GB	40 GB	$1.29	Standard training
A10	24 GB	$0.75	Inference, fine-tuning

Instance configurations

8x GPU: Best for distributed training (DDP, FSDP)
4x GPU: Large models, multi-GPU training
2x GPU: Medium workloads
1x GPU: Fine-tuning, inference, development

Launch times

Single-GPU: 3-5 minutes
Multi-GPU: 10-15 minutes

Lambda Stack

All instances come with Lambda Stack pre-installed:

# Included software
- Ubuntu 22.04 LTS
- NVIDIA drivers (latest)
- CUDA 12.x
- cuDNN 8.x
- NCCL (for multi-GPU)
- PyTorch (latest)
- TensorFlow (latest)
- JAX
- JupyterLab

Verify installation

# Check GPU
nvidia-smi

# Check PyTorch
python -c "import torch; print(torch.cuda.is_available())"

# Check CUDA version
nvcc --version

Python API

Installation

pip install lambda-cloud-client

Authentication

import os
import lambda_cloud_client

# Configure with API key
configuration = lambda_cloud_client.Configuration(
    host="https://cloud.lambdalabs.com/api/v1",
    access_token=os.environ["LAMBDA_API_KEY"]
)

List available instances

with lambda_cloud_client.ApiClient(configuration) as api_client:
    api = lambda_cloud_client.DefaultApi(api_client)

    # Get available instance types
    types = api.instance_types()
    for name, info in types.data.items():
        print(f"{name}: {info.instance_type.description}")

Launch instance

from lambda_cloud_client.models import LaunchInstanceRequest

request = LaunchInstanceRequest(
    region_name="us-west-1",
    instance_type_name="gpu_1x_h100_sxm5",
    ssh_key_names=["my-ssh-key"],
    file_system_names=["my-filesystem"],  # Optional
    name="training-job"
)

response = api.launch_instance(request)
instance_id = response.data.instance_ids[0]
print(f"Launched: {instance_id}")

List running instances

instances = api.list_instances()
for instance in instances.data:
    print(f"{instance.name}: {instance.ip} ({instance.status})")

Terminate instance

from lambda_cloud_client.models import TerminateInstanceRequest

request = TerminateInstanceRequest(
    instance_ids=[instance_id]
)
api.terminate_instance(request)

SSH key management

from lambda_cloud_client.models import AddSshKeyRequest

# Add SSH key
request = AddSshKeyRequest(
    name="my-key",
    public_key="ssh-rsa AAAA..."
)
api.add_ssh_key(request)

# List keys
keys = api.list_ssh_keys()

# Delete key
api.delete_ssh_key(key_id)

CLI with curl

List instance types

curl -u $LAMBDA_API_KEY: \
  https://cloud.lambdalabs.com/api/v1/instance-types | jq

Launch instance

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/launch \
  -H "Content-Type: application/json" \
  -d '{
    "region_name": "us-west-1",
    "instance_type_name": "gpu_1x_h100_sxm5",
    "ssh_key_names": ["my-key"]
  }' | jq

Terminate instance

curl -u $LAMBDA_API_KEY: \
  -X POST https://cloud.lambdalabs.com/api/v1/instance-operations/terminate \
  -H "Content-Type: application/json" \
  -d '{"instance_ids": ["<INSTANCE-ID>"]}' | jq

Persistent storage

Filesystems

Filesystems persist data across instance restarts:

# Mount location
/lambda/nfs/<FILESYSTEM_NAME>

# Example: save checkpoints
python train.py --checkpoint-dir /lambda/nfs/my-storage/checkpoints

Create filesystem

Go to Storage in Lambda console
Click "Create filesystem"
Select region (must match instance region)
Name and create

Attach to instance

Filesystems must be attached at instance launch time:

Via console: Select filesystem when launching
Via API: Include file_system_names in launch request

Best practices

# Store on filesystem (persists)
/lambda/nfs/storage/
  ├── datasets/
  ├── checkpoints/
  ├── models/
  └── outputs/

# Local SSD (faster, ephemeral)
/home/ubuntu/
  └── working/  # Temporary files

SSH configuration

Add SSH key

# Generate key locally
ssh-keygen -t ed25519 -f ~/.ssh/lambda_key

# Add public key to Lambda console
# Or via API

Multiple keys

# On instance, add more keys
echo 'ssh-rsa AAAA...' >> ~/.ssh/authorized_keys

Import from GitHub

# On instance
ssh-import-id gh:username

SSH tunneling

# Forward Jupyter
ssh -L 8888:localhost:8888 ubuntu@<IP>

# Forward TensorBoard
ssh -L 6006:localhost:6006 ubuntu@<IP>

# Multiple ports
ssh -L 8888:localhost:8888 -L 6006:localhost:6006 ubuntu@<IP>

JupyterLab

Launch from console

Go to Instances page
Click "Launch" in Cloud IDE column
JupyterLab opens in browser

Manual access

# On instance
jupyter lab --ip=0.0.0.0 --port=8888

# From local machine with tunnel
ssh -L 8888:localhost:8888 ubuntu@<IP>
# Open http://localhost:8888

Training workflows

Single-GPU training

# SSH to instance
ssh ubuntu@<IP>

# Clone repo
git clone https://github.com/user/project
cd project

# Install dependencies
pip install -r requirements.txt

# Train
python train.py --epochs 100 --checkpoint-dir /lambda/nfs/storage/checkpoints

Multi-GPU training (single node)

# train_ddp.py
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

def main():
    dist.init_process_group("nccl")
    rank = dist.get_rank()
    device = rank % torch.cuda.device_count()

    model = MyModel().to(device)
    model = DDP(model, device_ids=[device])

    # Training loop...

if __name__ == "__main__":
    main()



# Launch with torchrun (8 GPUs)
torchrun --nproc_per_node=8 train_ddp.py

Checkpoint to filesystem

import os

checkpoint_dir = "/lambda/nfs/my-storage/checkpoints"
os.makedirs(checkpoint_dir, exist_ok=True)

# Save checkpoint
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}, f"{checkpoint_dir}/checkpoint_{epoch}.pt")

1-Click Clusters

Overview

High-performance Slurm clusters with:

16-512 NVIDIA H100 or B200 GPUs
NVIDIA Quantum-2 400 Gb/s InfiniBand
GPUDirect RDMA at 3200 Gb/s
Pre-installed distributed ML stack

Included software

Ubuntu 22.04 LTS + Lambda Stack
NCCL, Open MPI
PyTorch with DDP and FSDP
TensorFlow
OFED drivers

Storage

24 TB NVMe per compute node (ephemeral)
Lambda filesystems for persistent data

Multi-node training

# On Slurm cluster
srun --nodes=4 --ntasks-per-node=8 --gpus-per-node=8 \
  torchrun --nnodes=4 --nproc_per_node=8 \
  --rdzv_backend=c10d --rdzv_endpoint=$MASTER_ADDR:29500 \
  train.py

Networking

Bandwidth

Inter-instance (same region): up to 200 Gbps
Internet outbound: 20 Gbps max

Firewall

Default: Only port 22 (SSH) open
Configure additional ports in Lambda console
ICMP traffic allowed by default

Private IPs

# Find private IP
ip addr show | grep 'inet '

Common workflows

Workflow 1: Fine-tuning LLM

# 1. Launch 8x H100 instance with filesystem

# 2. SSH and setup
ssh ubuntu@<IP>
pip install transformers accelerate peft

# 3. Download model to filesystem
python -c "
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf')
model.save_pretrained('/lambda/nfs/storage/models/llama-2-7b')
"

# 4. Fine-tune with checkpoints on filesystem
accelerate launch --num_processes 8 train.py \
  --model_path /lambda/nfs/storage/models/llama-2-7b \
  --output_dir /lambda/nfs/storage/outputs \
  --checkpoint_dir /lambda/nfs/storage/checkpoints

Workflow 2: Batch inference

# 1. Launch A10 instance (cost-effective for inference)

# 2. Run inference
python inference.py \
  --model /lambda/nfs/storage/models/fine-tuned \
  --input /lambda/nfs/storage/data/inputs.jsonl \
  --output /lambda/nfs/storage/data/outputs.jsonl

Cost optimization

Choose right GPU

Task	Recommended GPU
LLM fine-tuning (7B)	A100 40GB
LLM fine-tuning (70B)	8x H100
Inference	A10, A6000
Development	V100, A10
Maximum performance	B200

Reduce costs

Use filesystems : Avoid re-downloading data
Checkpoint frequently : Resume interrupted training
Right-size : Don't over-provision GPUs
Terminate idle : No auto-stop, manually terminate

Monitor usage

Dashboard shows real-time GPU utilization
API for programmatic monitoring

Common issues

Issue	Solution
Instance won't launch	Check region availability, try different GPU
SSH connection refused	Wait for instance to initialize (3-15 min)
Data lost after terminate	Use persistent filesystems
Slow data transfer	Use filesystem in same region
GPU not detected	Reboot instance, check drivers

References

Advanced Usage - Multi-node training, API automation
Troubleshooting - Common issues and solutions

Resources

Documentation : https://docs.lambda.ai
Console : https://cloud.lambda.ai
Pricing : https://lambda.ai/instances
Support : https://support.lambdalabs.com
Blog : https://lambda.ai/blog

Weekly Installs

147

Repository

davila7/claude-…emplates

GitHub Stars

22.6K

First Seen

Jan 21, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

Installed on

claude-code116

opencode114

gemini-cli111

cursor108

codex98

antigravity95

Azure 配额管理指南：服务限制、容量验证与配额增加方法

102,500 周安装

Lambda Labs GPU云：按需GPU实例与一键集群，专为AI/机器学习训练优化

🇨🇳中文介绍

Lambda Labs GPU 云

何时使用 Lambda Labs

快速开始

账户设置

相关 Skills

通过控制台启动

通过 SSH 连接

GPU 实例

可用 GPU

实例配置

启动时间

Lambda Stack

验证安装

Python API

安装

认证

列出可用实例

启动实例

列出运行中的实例

终止实例

SSH 密钥管理

使用 curl 的 CLI

列出实例类型

启动实例

终止实例

持久存储

文件系统

创建文件系统

附加到实例

最佳实践

SSH 配置

添加 SSH 密钥

多个密钥

从 GitHub 导入

SSH 隧道

JupyterLab

从控制台启动

手动访问

训练工作流

单 GPU 训练

多 GPU 训练（单节点）

将检查点保存到文件系统

一键式集群

概述

包含的软件

存储

多节点训练

网络

带宽

防火墙

私有 IP

常见工作流

工作流 1：微调 LLM

工作流 2：批量推理

成本优化

选择合适的 GPU

降低成本

监控使用情况

常见问题

参考

资源

🇺🇸English

Lambda Labs GPU Cloud

When to use Lambda Labs

Quick start

Account setup

Launch via console

Connect via SSH

GPU instances

Available GPUs

Instance configurations

Launch times

Lambda Stack

Verify installation

Python API

Installation

Authentication

List available instances