pulumi-bunnynet
Version:
A Pulumi provider for managing Bunny.net CDN and edge computing resources, dynamically bridged from the Terraform Bunnynet provider with support for pull zones, storage, DNS, compute containers, and video streaming.
349 lines (263 loc) • 9.37 kB
Markdown
# Pulumi Bunnynet Provider
A Pulumi provider for managing Bunny.net CDN and edge computing resources, dynamically bridged from the [Terraform Bunnynet Provider](https://github.com/bunnyway/terraform-provider-bunnynet).
## Introduction
This package provides a Pulumi provider that enables you to manage your Bunny.net CDN, storage, DNS, compute containers, and video streaming resources using TypeScript, JavaScript, Python, Go, or C#. The provider is automatically generated from the Terraform Bunnynet provider, giving you access to all its functionality within the Pulumi ecosystem.
### Features
- **Pull Zones (CDN)**: Create and manage CDN pull zones with edge rules, hostnames, and optimizer classes
- **Storage Management**: Manage storage zones and files for global content delivery
- **DNS Management**: Configure DNS zones and records for your domains
- **Compute Containers**: Deploy and manage container applications at the edge
- **Video Streaming**: Set up video libraries, collections, and streaming content
- **Edge Computing**: Configure compute scripts with variables and secrets
- **TypeScript Support**: Full type safety with comprehensive TypeScript definitions
## Installation
### npm
```bash
npm install pulumi-bunnynet
```
### yarn
```bash
yarn add pulumi-bunnynet
```
### pnpm
```bash
pnpm add pulumi-bunnynet
```
## Configuration
Before using the provider, you need to configure authentication with your Bunny.net API credentials.
### Required Configuration
- **API Key**: Your Bunny.net API key
- **Access Key**: Your storage access key (for storage operations)
### Setting Configuration
You can configure the provider in several ways:
#### 1. Using Pulumi Config
```bash
pulumi config set bunnynet:apiKey your-api-key
pulumi config set bunnynet:accessKey your-access-key
```
#### 2. Using Environment Variables
```bash
export BUNNYNET_API_KEY="your-api-key"
export BUNNYNET_ACCESS_KEY="your-access-key"
```
#### 3. Provider Constructor
```typescript
import * as bunnynet from 'pulumi-bunnynet'
const provider = new bunnynet.Provider('bunnynet-provider', {
apiKey: 'your-api-key',
accessKey: 'your-access-key',
})
```
## Usage
### Pull Zone Management
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Create a pull zone for CDN
const pullZone = new bunnynet.Pullzone('my-cdn', {
name: 'my-website-cdn',
originUrl: 'https://my-website.com',
type: 'standard',
storageZoneId: 12345,
cacheControlMaxAge: 3600,
cacheControlPublicMaxAge: 86400,
addCanonicalHeader: true,
enableGeoipCountryCode: true,
enableOriginShield: true,
})
// Add a custom hostname
const hostname = new bunnynet.PullzoneHostname('custom-domain', {
pullzoneId: pullZone.id,
hostname: 'cdn.my-website.com',
certificateId: 67890,
})
// Create edge rules
const edgeRule = new bunnynet.PullzoneEdgerule('cache-rule', {
pullzoneId: pullZone.id,
actionType: 'SetCacheTime',
triggerType: 'RequestHeader',
triggerValue: 'X-Cache-Control',
actionParameter1: '3600',
})
```
### Storage Management
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Create a storage zone
const storageZone = new bunnynet.StorageZone('media-storage', {
name: 'media-files',
region: 'NY', // New York region
replicationRegions: ['LA', 'SG'], // Los Angeles and Singapore replicas
})
// Upload files to storage
const file = new bunnynet.StorageFile('logo', {
storageZoneName: storageZone.name,
path: '/images/logo.png',
source: './assets/logo.png',
contentType: 'image/png',
})
```
### DNS Management
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Create DNS zone
const dnsZone = new bunnynet.DnsZone('my-domain', {
domain: 'example.com',
soaEmail: 'admin@example.com',
})
// Add DNS records
const aRecord = new bunnynet.DnsRecord('www-record', {
zoneId: dnsZone.id,
type: 'A',
name: 'www',
value: '203.0.113.1',
ttl: 3600,
})
const cnameRecord = new bunnynet.DnsRecord('cdn-record', {
zoneId: dnsZone.id,
type: 'CNAME',
name: 'cdn',
value: 'b-cdn.net',
ttl: 3600,
})
```
### Compute Container Applications
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Create container image registry
const registry = new bunnynet.ComputeContainerImageregistry('my-registry', {
name: 'my-app-registry',
imageUrl: 'docker.io/myorg/myapp:latest',
username: 'myusername',
password: 'mypassword',
})
// Deploy container app
const containerApp = new bunnynet.ComputeContainerApp('edge-app', {
name: 'my-edge-app',
imageRegistryId: registry.id,
environmentVariables: [
{
name: 'NODE_ENV',
value: 'production',
},
{
name: 'API_URL',
value: 'https://api.example.com',
},
],
cpu: 0.1,
memory: 128,
})
```
### Video Streaming
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Create video library
const videoLibrary = new bunnynet.StreamLibrary('video-content', {
name: 'my-video-library',
storageZoneId: 12345,
replicationRegions: ['NY', 'LA', 'SG'],
watermarkPositionLeft: 10,
watermarkPositionTop: 10,
watermarkWidth: 100,
watermarkHeight: 50,
})
// Create video collection
const collection = new bunnynet.StreamCollection('tutorials', {
libraryId: videoLibrary.id,
name: 'Tutorial Videos',
})
// Upload video
const video = new bunnynet.StreamVideo('intro-video', {
libraryId: videoLibrary.id,
title: 'Introduction Tutorial',
collectionId: collection.id,
// Video will be uploaded separately via API or dashboard
})
```
### Compute Scripts
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Create compute script
const script = new bunnynet.ComputeScript('edge-function', {
name: 'my-edge-function',
scriptType: 'standalone',
code: `
async function handleRequest(request) {
const response = await fetch(request);
const body = await response.text();
// Add custom header
const headers = new Headers(response.headers);
headers.set('X-Processed-By', 'Bunny-Edge');
return new Response(body, {
status: response.status,
headers: headers
});
}
addEventListener('fetch', event => {
event.respondWith(handleRequest(event.request));
});
`,
})
// Add script variables
const scriptVar = new bunnynet.ComputeScriptVariable('api-endpoint', {
scriptId: script.id,
name: 'API_ENDPOINT',
value: 'https://api.example.com/v1',
})
// Add script secrets
const scriptSecret = new bunnynet.ComputeScriptSecret('api-key', {
scriptId: script.id,
name: 'API_KEY',
value: 'secret-api-key-value',
})
```
## Resources
### Pull Zones
- **Pullzone**: Main CDN pull zone configuration
- **PullzoneHostname**: Custom domains for pull zones
- **PullzoneEdgerule**: Cache and routing rules
- **PullzoneOptimizerClass**: Image optimization settings
### Storage
- **StorageZone**: Global storage zones
- **StorageFile**: Individual file management
### DNS
- **DnsZone**: DNS zone management
- **DnsRecord**: Individual DNS records (A, AAAA, CNAME, MX, TXT, etc.)
### Compute
- **ComputeContainerApp**: Edge container applications
- **ComputeContainerImageregistry**: Container image registries
- **ComputeScript**: Edge computing scripts
- **ComputeScriptVariable**: Script environment variables
- **ComputeScriptSecret**: Script secrets
### Video Streaming
- **StreamLibrary**: Video libraries
- **StreamCollection**: Video collections
- **StreamVideo**: Individual videos
## API Reference
For detailed API documentation, see the generated documentation in your IDE or visit the [Pulumi Registry](https://www.pulumi.com/registry/).
## Authentication Setup
### Getting Your API Credentials
1. **Log in to Bunny.net**: Go to your Bunny.net dashboard
2. **Navigate to Account Settings**: Click on your profile → Account Settings
3. **Generate API Key**: Go to API section and create a new API key
4. **Storage Access Key**: For storage operations, get your access key from Storage → FTP & API Access
5. **Note Your Details**: Save your API key and access key securely
### Testing Your Setup
```typescript
import * as bunnynet from 'pulumi-bunnynet'
// Test with a simple resource query
const regions = bunnynet.getRegion({})
```
## Examples
You can find more examples in the [examples directory](./examples) or check out these common use cases:
- [Basic CDN Setup](./examples/basic-cdn)
- [Storage and File Management](./examples/storage-management)
- [DNS Configuration](./examples/dns-setup)
- [Edge Computing](./examples/edge-computing)
- [Video Streaming Platform](./examples/video-streaming)
## Support
This provider is a derived work of the [Terraform Provider](https://github.com/bunnyway/terraform-provider-bunnynet) distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/).
If you encounter a bug or missing feature, please consult the source [`terraform-provider-bunnynet` repo](https://github.com/bunnyway/terraform-provider-bunnynet/issues).
For Pulumi-specific issues, please open an issue in the [pulumi-any-terraform repository](https://github.com/hckhanh/pulumi-any-terraform).
## License
This package is distributed under the MIT License. The underlying Terraform provider is distributed under MPL 2.0.