PHP code example of redberry / laravel-cloud-sdk

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

redberry / laravel-cloud-sdk example snippets

use Redberry\LaravelCloudSdk\Facades\LaravelCloud;

$applications = LaravelCloud::applications();

$cloud = LaravelCloud::forToken($user->cloud_token);
$applications = $cloud->applications();

use Redberry\LaravelCloudSdk\LaravelCloud;

$cloud = new LaravelCloud($token);

use Redberry\LaravelCloudSdk\Enums\CloudRegion;
use Redberry\LaravelCloudSdk\Enums\SourceControlProvider;

// Using enums (recommended)
LaravelCloud::createApplication(
    repository: 'my-org/my-repo',
    name: 'my-app',
    region: CloudRegion::UsEast1,
    sourceControlProviderType: SourceControlProvider::Github,
);

// Using strings - equally valid
LaravelCloud::createApplication(
    repository: 'my-org/my-repo',
    name: 'my-app',
    region: 'us-east-1',
    sourceControlProviderType: 'github',
);

$app = LaravelCloud::application('app-123');
$app->region; // CloudRegion::UsEast1

$newRegionApp = LaravelCloud::application('app-456');
$newRegionApp->region; // "ap-northeast-1" (new region the SDK doesn't know about yet - still works)

// Iterates through all pages automatically
$applications = LaravelCloud::applications();

foreach ($applications as $application) {
    echo $application->name;
}

// Standard collection operations work seamlessly
$names = LaravelCloud::applications()->map(fn ($app) => $app->name);
$production = LaravelCloud::environments($appId)->filter(fn ($env) => $env->name === 'production');

$environment = LaravelCloud::environment($environmentId);

$environment->name;             // "production"
$environment->status;           // EnvironmentStatus::Running
$environment->phpMajorVersion;  // PhpVersion::V8_4
$environment->createdAt;        // CarbonImmutable instance

$environments = LaravelCloud::environments($applicationId);

$environments->each(function (EnvironmentData $environment) {
    echo $environment->name;
});

$environment = LaravelCloud::environment($environmentId);

$environment->application;          // ApplicationData
$environment->instances;            // InstanceData[]
$environment->currentDeployment;    // ?DeploymentData
$environment->database;             // ?DatabaseData
$environment->cache;                // ?CacheData

// Relationships are also loaded on list results
$environments = LaravelCloud::environments($applicationId);

$environments->each(function (EnvironmentData $env) {
    echo $env->application->name;           // loaded automatically
    echo count($env->instances) . ' instances';
});

$application = LaravelCloud::application($applicationId);

$application->organization;         // ?OrganizationData
$application->environments;         // EnvironmentData[]

$application = LaravelCloud::createApplication(
    repository: 'my-org/my-repo',
    name: 'my-application',
    region: CloudRegion::UsEast1,
    sourceControlProviderType: SourceControlProvider::Github,
);

$application = LaravelCloud::updateApplication($applicationId,
    name: 'new-name',
    slackChannel: '#deployments',
);

use Redberry\LaravelCloudSdk\Data\Applications\CreateApplicationData;

$application = LaravelCloud::createApplicationWith(
    new CreateApplicationData(
        repository: 'my-org/my-repo',
        name: 'my-application',
        region: CloudRegion::UsEast1,
        sourceControlProviderType: SourceControlProvider::Github,
    )
);

LaravelCloud::deleteApplication($applicationId);
LaravelCloud::deleteEnvironment($environmentId);
LaravelCloud::deleteDomain($domainId);

$applications = LaravelCloud::applications();

$application = LaravelCloud::application($applicationId);

$application = LaravelCloud::createApplication(
    repository: 'my-org/my-repo',
    name: 'my-application',
    region: CloudRegion::UsEast1,
    sourceControlProviderType: SourceControlProvider::Github,
);

$application = LaravelCloud::updateApplication($applicationId,
    name: 'new-name',
    slackChannel: '#deployments',
);

LaravelCloud::deleteApplication($applicationId);

$application = LaravelCloud::uploadApplicationAvatar($applicationId, avatarPath: '/path/to/avatar.png');

LaravelCloud::deleteApplicationAvatar($applicationId);

$environments = LaravelCloud::environments($applicationId);

$environment = LaravelCloud::environment($environmentId);

$environment = LaravelCloud::createEnvironment($applicationId,
    name: 'staging',
    branch: 'develop',
);

use Redberry\LaravelCloudSdk\Enums\PhpVersion;
use Redberry\LaravelCloudSdk\Enums\NodeVersion;

$environment = LaravelCloud::updateEnvironment($environmentId,
    phpVersion: PhpVersion::V8_4,
    nodeVersion: NodeVersion::V22,
    usesPushToDeploy: true,
    buildCommand: 'npm run build',
    deployCommand: 'php artisan migrate --force',
);

// Start - optionally force a redeploy
$deployment = LaravelCloud::startEnvironment($environmentId, redeploy: true);

// Stop
$environment = LaravelCloud::stopEnvironment($environmentId);

LaravelCloud::deleteEnvironment($environmentId);

use Redberry\LaravelCloudSdk\Enums\EnvironmentVariableMethod;

// Add or update specific variables
$environment = LaravelCloud::setEnvironmentVariables($environmentId,
    method: EnvironmentVariableMethod::Append,
    variables: [
        ['key' => 'APP_DEBUG', 'value' => 'false'],
        ['key' => 'CACHE_DRIVER', 'value' => 'redis'],
    ],
);

// Remove specific variables by key
$environment = LaravelCloud::deleteEnvironmentVariables($environmentId,
    keys: ['APP_DEBUG', 'CACHE_DRIVER'],
);

use Redberry\LaravelCloudSdk\Enums\MetricPeriod;

$metrics = LaravelCloud::environmentMetrics($environmentId);

// With a specific time period
$metrics = LaravelCloud::environmentMetrics($environmentId, period: MetricPeriod::SevenDays);

use Redberry\LaravelCloudSdk\Enums\LogFilterType;

$logs = LaravelCloud::environmentLogs(
    $environmentId,
    from: '2025-01-01T00:00:00Z',
    to: '2025-01-02T00:00:00Z',
    searchQuery: 'Exception',
    type: LogFilterType::Application,
);

foreach ($logs as $entry) {
    echo "[{$entry->level}] {$entry->message}";
}

$deployments = LaravelCloud::deployments($environmentId);

$deployment = LaravelCloud::deployment($deploymentId);

$deployment = LaravelCloud::deploy($environmentId);

$logs = LaravelCloud::deploymentLogs($deploymentId);

// Build phase
foreach ($logs->build->steps as $step) {
    echo "{$step->step}: {$step->status} ({$step->durationMs}ms)\n";
    echo $step->output;
}

// Deploy phase
foreach ($logs->deploy->steps as $step) {
    echo "{$step->step}: {$step->status}\n";
}

$instances = LaravelCloud::instances($environmentId);

$instance = LaravelCloud::instance($instanceId);

use Redberry\LaravelCloudSdk\Enums\InstanceType;
use Redberry\LaravelCloudSdk\Enums\InstanceSize;
use Redberry\LaravelCloudSdk\Enums\InstanceScalingType;

$instance = LaravelCloud::createInstance($environmentId,
    name: 'web',
    type: InstanceType::App,
    size: InstanceSize::FlexG2vcpu1gb,
    scalingType: InstanceScalingType::Custom,
    maxReplicas: 5,
    minReplicas: 1,
);

$instance = LaravelCloud::updateInstance($instanceId,
    size: InstanceSize::FlexM8vcpu8gb,
);

LaravelCloud::deleteInstance($instanceId);

$sizes = LaravelCloud::instanceSizes();

$processes = LaravelCloud::backgroundProcesses($instanceId);

$process = LaravelCloud::backgroundProcess($processId);

use Redberry\LaravelCloudSdk\Enums\DaemonType;
use Redberry\LaravelCloudSdk\Data\BackgroundProcesses\BackgroundProcessConfigData;

// A queue worker
$process = LaravelCloud::createBackgroundProcess($instanceId,
    type: DaemonType::Worker,
    processes: 3,
    config: new BackgroundProcessConfigData(
        connection: 'redis',
        queue: 'default,emails',
        tries: 3,
        timeout: 60,
    ),
);

// A custom daemon
$process = LaravelCloud::createBackgroundProcess($instanceId,
    type: DaemonType::Custom,
    processes: 1,
    command: 'php artisan horizon',
);

$process = LaravelCloud::updateBackgroundProcess($processId,
    processes: 5,
);

LaravelCloud::deleteBackgroundProcess($processId);

$commands = LaravelCloud::commands($environmentId);

$command = LaravelCloud::command($commandId);

$command = LaravelCloud::runCommand($environmentId, command: 'php artisan migrate --force');

$domains = LaravelCloud::domains($environmentId);

$domain = LaravelCloud::domain($domainId);

use Redberry\LaravelCloudSdk\Enums\DomainRedirect;
use Redberry\LaravelCloudSdk\Enums\DomainVerificationMethod;

$domain = LaravelCloud::createDomain($environmentId,
    name: 'example.com',
    wwwRedirect: DomainRedirect::WwwToRoot,
    verificationMethod: DomainVerificationMethod::RealTime,
);

$domain = LaravelCloud::updateDomain($domainId,
    verificationMethod: DomainVerificationMethod::PreVerification,
);

$domain = LaravelCloud::verifyDomain($domainId);

LaravelCloud::deleteDomain($domainId);

$clusters = LaravelCloud::databaseClusters();

$cluster = LaravelCloud::databaseCluster($clusterId);

use Redberry\LaravelCloudSdk\Enums\DatabaseType;
use Redberry\LaravelCloudSdk\Enums\DatabaseClusterSize;
use Redberry\LaravelCloudSdk\Data\DatabaseClusters\LaravelMysqlConfigData;

$cluster = LaravelCloud::createDatabaseCluster(
    name: 'production-db',
    type: DatabaseType::LaravelMysql84,
    region: CloudRegion::UsEast1,
    config: new LaravelMysqlConfigData(
        size: DatabaseClusterSize::Flex1vcpu1gb,
        storage: 10,
        isPublic: false,
        usesScheduledSnapshots: true,
        retentionDays: 7,
        maintenanceWindow: null,
    ),
);

$cluster = LaravelCloud::updateDatabaseCluster($clusterId,
    config: new LaravelMysqlConfigData(
        size: DatabaseClusterSize::Flex1vcpu2gb,
        storage: 20,
        isPublic: false,
        usesScheduledSnapshots: true,
        retentionDays: 14,
        maintenanceWindow: null,
    ),
);

LaravelCloud::deleteDatabaseCluster($clusterId);

$metrics = LaravelCloud::databaseClusterMetrics($clusterId);
$metrics = LaravelCloud::databaseClusterMetrics($clusterId, period: MetricPeriod::SevenDays);

$types = LaravelCloud::databaseTypes();

$snapshot = LaravelCloud::createDatabaseSnapshot($clusterId,
    name: 'pre-migration-backup',
    description: 'Before running v2 migrations',
);

$snapshots = LaravelCloud::databaseSnapshots($clusterId);

$snapshot = LaravelCloud::databaseSnapshot($snapshotId);

// Restore from a specific snapshot
$cluster = LaravelCloud::restoreDatabaseCluster($clusterId,
    name: 'restored-cluster',
    databaseSnapshotId: $snapshotId,
);

// Restore to a specific point in time
$cluster = LaravelCloud::restoreDatabaseCluster($clusterId,
    name: 'restored-cluster',
    restoreTime: '2025-06-15T14:30:00Z',
);

LaravelCloud::deleteDatabaseSnapshot($snapshotId);

$databases = LaravelCloud::databases($clusterId);

$database = LaravelCloud::database($clusterId, $databaseId);

$database = LaravelCloud::createDatabase($clusterId,
    name: 'my_database',
);

LaravelCloud::deleteDatabase($clusterId, $databaseId);

$caches = LaravelCloud::caches();

$cache = LaravelCloud::cache($cacheId);

use Redberry\LaravelCloudSdk\Enums\CacheType;
use Redberry\LaravelCloudSdk\Enums\CacheSize;

$cache = LaravelCloud::createCache(
    type: CacheType::LaravelValkey,
    name: 'production-cache',
    region: CloudRegion::UsEast1,
    size: CacheSize::Flex256mb,
    autoUpgradeEnabled: true,
    isPublic: false,
);

$cache = LaravelCloud::updateCache($cacheId,
    size: CacheSize::Flex512mb,
);

LaravelCloud::deleteCache($cacheId);

$metrics = LaravelCloud::cacheMetrics($cacheId);
$metrics = LaravelCloud::cacheMetrics($cacheId, period: MetricPeriod::TwentyFourHours);

$types = LaravelCloud::cacheTypes();

$buckets = LaravelCloud::buckets();

$bucket = LaravelCloud::bucket($bucketId);

use Redberry\LaravelCloudSdk\Enums\BucketVisibility;
use Redberry\LaravelCloudSdk\Enums\BucketJurisdiction;
use Redberry\LaravelCloudSdk\Enums\KeyPermission;

$bucket = LaravelCloud::createBucket(
    name: 'media-storage',
    visibility: BucketVisibility::Private,
    jurisdiction: BucketJurisdiction::Eu,
    keyName: 'default-key',
    keyPermission: KeyPermission::ReadWrite,
);

$bucket = LaravelCloud::updateBucket($bucketId,
    name: 'new-bucket-name',
);

LaravelCloud::deleteBucket($bucketId);

$keys = LaravelCloud::bucketKeys($bucketId);

$key = LaravelCloud::bucketKey($keyId);

$key = LaravelCloud::createBucketKey($bucketId,
    name: 'upload-key',
    permission: KeyPermission::ReadWrite,
);

$key = LaravelCloud::updateBucketKey($keyId, name: 'new-key-name');

LaravelCloud::deleteBucketKey($keyId);

$clusters = LaravelCloud::websocketClusters();

$cluster = LaravelCloud::websocketCluster($clusterId);

use Redberry\LaravelCloudSdk\Enums\WebsocketServerType;
use Redberry\LaravelCloudSdk\Enums\WebsocketMaxConnections;

$cluster = LaravelCloud::createWebsocketCluster(
    name: 'production-ws',
    type: WebsocketServerType::Reverb,
    region: CloudRegion::UsEast1,
    maxConnections: WebsocketMaxConnections::V500,
);

$cluster = LaravelCloud::updateWebsocketCluster($clusterId,
    maxConnections: WebsocketMaxConnections::V2000,
);

LaravelCloud::deleteWebsocketCluster($clusterId);

$metrics = LaravelCloud::websocketClusterMetrics($clusterId);
$metrics = LaravelCloud::websocketClusterMetrics($clusterId, period: MetricPeriod::TwentyFourHours);

$applications = LaravelCloud::websocketApplications($clusterId);

$application = LaravelCloud::websocketApplication($applicationId);

$application = LaravelCloud::createWebsocketApplication($clusterId,
    name: 'my-ws-app',
);

$application = LaravelCloud::updateWebsocketApplication($applicationId,
    name: 'new-ws-app-name',
);

LaravelCloud::deleteWebsocketApplication($applicationId);

$metrics = LaravelCloud::websocketApplicationMetrics($applicationId);
$metrics = LaravelCloud::websocketApplicationMetrics($applicationId, period: MetricPeriod::SevenDays);

use Redberry\LaravelCloudSdk\Enums\ClusterType;
use Redberry\LaravelCloudSdk\Enums\ClusterStatus;

// List all dedicated clusters
$clusters = LaravelCloud::dedicatedClusters();

// Filter by type and region
$clusters = LaravelCloud::dedicatedClusters(
    region: CloudRegion::UsEast1,
    type: ClusterType::Applications,
    status: ClusterStatus::Active,
);

$org = LaravelCloud::organization();

$org->id;   // "org-abc123"
$org->name; // "My Team"
$org->slug; // "my-team"

$regions = LaravelCloud::regions();

// All regions
$addresses = LaravelCloud::ipAddresses();

// Specific region
$addresses = LaravelCloud::ipAddresses(region: CloudRegion::UsEast1);

bash
php artisan vendor:publish --tag=cloud-sdk-config

php
// In your Pest.php
Saloon::preventStrayRequests();