Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: add scripts for azure container registry (#17893)
ecmadaofb9c26c5054b
diff --git a/.gitignore b/.gitignoreindex 6dfac33c2c..c6313a4692 100644--- a/.gitignore+++ b/.gitignore@@ -27,3 +27,8 @@ bytebase-build.idea.DS_Store++# Azure Marketplace build artifacts+scripts/azure-marketplace/.cnab/+scripts/azure-marketplace/*.tgz+scripts/azure-marketplace/*.backupdiff --git a/helm-charts/bytebase/templates/statefulset.yaml b/helm-charts/bytebase/templates/statefulset.yamlindex 6cec2ecd95..66b0df86e8 100644--- a/helm-charts/bytebase/templates/statefulset.yaml+++ b/helm-charts/bytebase/templates/statefulset.yaml@@ -111,7 +111,31 @@ spec:{{- end }}containers:- name: bytebase- {{- if $registryMirrorHost }}+ {{- if .Values.global }}+ {{- if .Values.global.azure }}+ {{- if .Values.global.azure.images }}+ {{- if .Values.global.azure.images.bytebase }}+ # Azure Marketplace image path - Microsoft will retag images to their registry+ image: {{ .Values.global.azure.images.bytebase.registry }}/{{ .Values.global.azure.images.bytebase.image }}:{{ .Values.global.azure.images.bytebase.tag }}+ {{- else if $registryMirrorHost }}+ # If user specifies a registry mirror host, we should use that instead of the default.+ image: {{ trimSuffix "/" $registryMirrorHost }}/bytebase/bytebase:{{ $version }}+ {{- else }}+ image: bytebase/bytebase:{{ $version }}+ {{- end }}+ {{- else if $registryMirrorHost }}+ # If user specifies a registry mirror host, we should use that instead of the default.+ image: {{ trimSuffix "/" $registryMirrorHost }}/bytebase/bytebase:{{ $version }}+ {{- else }}+ image: bytebase/bytebase:{{ $version }}+ {{- end }}+ {{- else if $registryMirrorHost }}+ # If user specifies a registry mirror host, we should use that instead of the default.+ image: {{ trimSuffix "/" $registryMirrorHost }}/bytebase/bytebase:{{ $version }}+ {{- else }}+ image: bytebase/bytebase:{{ $version }}+ {{- end }}+ {{- else if $registryMirrorHost }}# If user specifies a registry mirror host, we should use that instead of the default.image: {{ trimSuffix "/" $registryMirrorHost }}/bytebase/bytebase:{{ $version }}{{- else }}diff --git a/helm-charts/bytebase/values.yaml b/helm-charts/bytebase/values.yamlindex 5cc18f832e..c1ebb918e5 100644--- a/helm-charts/bytebase/values.yaml+++ b/helm-charts/bytebase/values.yaml@@ -2,6 +2,17 @@# This is a YAML-formatted file.# Declare variables to be passed into your templates.+# Global Azure Marketplace image configuration+# This section is used when deploying from Azure Marketplace+# Azure will retag and host images in their registry+global:+ azure:+ images:+ bytebase:+ tag: latest+ image: bytebase/bytebase+ registry: docker.io+bytebase:version: latestregistryMirrorHost: ""diff --git a/scripts/azure-marketplace/PARTNER_CENTER_GUIDE.md b/scripts/azure-marketplace/PARTNER_CENTER_GUIDE.mdnew file mode 100644index 0000000000..7646c51c2e--- /dev/null+++ b/scripts/azure-marketplace/PARTNER_CENTER_GUIDE.md@@ -0,0 +1,618 @@+# Partner Center Setup Guide for Bytebase++This guide provides detailed, step-by-step instructions for creating your Bytebase offer in Microsoft Partner Center.++## Prerequisites++Before you start, ensure you have:+- ✅ Partner Center account with publisher access+- ✅ CNAB bundle uploaded to ACR: `bytebase.azurecr.io/bytebase:3.11.1`+- ✅ Legal documents ready (Terms of Service, Privacy Policy URLs)+- ✅ Marketing materials (screenshots, description, logo)+- ✅ Support contact information++---++## Part 1: Create New Offer (10 minutes)++### Step 1: Access Partner Center++1. Navigate to: https://partner.microsoft.com/dashboard+2. Sign in with your Microsoft account+3. Click on **"Commercial Marketplace"** in the left navigation+4. Click **"Overview"**++### Step 2: Create New Offer++1. Click **"+ New offer"** button (top right)+2. Select **"Azure Container"** from the dropdown+3. A popup will appear: **"New Azure Container offer"**++4. Fill in the form:+ - **Offer ID**: `bytebase`+ - This is permanent and cannot be changed+ - Must be unique in your publisher namespace+ - Use lowercase, no spaces (hyphens allowed)++ - **Offer alias**: `Bytebase - Database CI/CD`+ - Internal name for your reference+ - Can be changed later++5. Click **"Create"**++### Step 3: Initial Setup++The offer will be created and you'll see the offer management page with tabs:+- Offer setup+- Properties+- Offer listing+- Preview audience+- Technical configuration+- Plan overview+- Co-sell with Microsoft (optional)+- Resell through CSPs (optional)++---++## Part 2: Offer Setup (5 minutes)++Click on **"Offer setup"** tab.++### Customer Leads (Optional but Recommended)++1. **Connect a CRM system** (optional):+ - If you want to receive customer contact info+ - Options: Azure Table, Dynamics 365, Marketo, Salesforce, HTTPS endpoint+ - For now, you can skip this++2. **Test connection**: Click "Validate" if you configured CRM++3. Click **"Save draft"** at the bottom++---++## Part 3: Properties (5 minutes)++Click on **"Properties"** tab.++### Categories++Select up to 2 primary categories:+1. **Primary**: `Databases`+2. **Secondary**: `Developer Tools`++### Legal++You must provide legal documents:++1. **Standard Contract**:+ - ☑ Check "Use the Standard Contract for Microsoft's commercial marketplace"+ - This simplifies legal compliance++2. **Terms and Conditions** (If NOT using Standard Contract):+ - Enter URL to your Terms of Service+ - Example: `https://www.bytebase.com/terms`++3. **Privacy Policy**:+ - **Required**: Enter URL to your Privacy Policy+ - Example: `https://www.bytebase.com/privacy`++4. Click **"Save draft"**++---++## Part 4: Offer Listing (20 minutes)++Click on **"Offer listing"** tab.++This is what customers see on Azure Marketplace. Take time to make it compelling!++### Basic Information++1. **Name**: `Bytebase`+ - This is the display name customers see+ - Keep it simple and recognizable++2. **Search results summary** (100 characters max):+ ```+ Safe database schema change and version control for DevOps teams+ ```++3. **Short description** (256 characters max):+ ```+ Bytebase is a database CI/CD tool that helps DevOps teams manage database schema changes safely and efficiently. Deploy schema migrations, track changes, and enforce policies across all your databases from a single platform.+ ```++4. **Description** (3000 characters max):+ ```markdown+ ## Database Schema Change and Version Control++ Bytebase is an all-in-one database CI/CD solution that helps developers and DBAs manage database schema changes throughout the application development lifecycle.++ ### Key Features++ **Schema Migration**+ - Visual schema editor with SQL syntax highlighting+ - Automated migration scripts generation+ - Rollback support for failed migrations+ - Multi-environment deployment workflows++ **Version Control Integration**+ - GitOps-style database change management+ - Integrated with GitHub, GitLab, and Bitbucket+ - Pull request-based review workflow+ - Automated deployment on merge++ **Policy Enforcement**+ - Customizable approval workflows+ - SQL review and best practices enforcement+ - Automated schema validation+ - Compliance audit trails++ **Database Support**+ - MySQL, PostgreSQL, Oracle, SQL Server+ - MongoDB, Redis, Snowflake, BigQuery+ - And many more database engines++ **Team Collaboration**+ - Role-based access control (RBAC)+ - Change history and audit logs+ - Slack and email notifications+ - Multi-project and multi-environment support++ ### Why Bytebase?++ - **Safety**: Prevent schema migration failures with automated validation+ - **Efficiency**: Streamline database change workflows for your team+ - **Compliance**: Built-in audit trails and approval processes+ - **Scalability**: Manage hundreds of databases across environments++ ### Get Started++ Deploy Bytebase to your Azure Kubernetes Service (AKS) cluster in minutes. Configure your external PostgreSQL database for metadata storage, and you're ready to manage your database schema changes.++ ### Support++ - Documentation: https://docs.bytebase.com+ - Community: https://github.com/bytebase/bytebase+ - Enterprise Support: [email protected]+ ```++### Links++1. **Privacy policy URL**: `https://www.bytebase.com/privacy`+2. **Support website**: `https://docs.bytebase.com`+3. **Engineering contact** (private, for Microsoft):+ - Name: `[Your Name]`+ - Email: `[email protected]`+ - Phone: `[Your Phone]`++4. **Support contact** (public, shown to customers):+ - Name: `Bytebase Support`+ - Email: `[email protected]`+ - Phone: `[Optional]`++### Marketing Materials++#### Supporting Documents (Optional)+- Upload PDFs, videos, or other marketing materials+- Examples: product briefs, case studies, whitepapers++#### Marketplace Media++**Logo (Required)**:+- Small (48x48 pixels): PNG format+- Medium (90x90 pixels): PNG format+- Large (216x216 pixels): PNG format+- Wide (255x115 pixels): PNG format++> **Tip**: Use your Bytebase logo from: `helm-charts/bytebase/Chart.yaml` (icon field)+> You'll need to download and resize it to the required dimensions.++**Screenshots (Required - At least 1, up to 5)**:+- Size: 1280x720 or 1920x1080 pixels+- Format: PNG+- Include captions (max 100 characters each)++Suggested screenshots:+1. **Main Dashboard**: Show database overview and recent changes+ - Caption: "Centralized database management dashboard"+2. **Schema Migration**: Show migration editor and workflow+ - Caption: "Visual schema migration editor with SQL support"+3. **Version Control**: Show GitOps integration+ - Caption: "GitOps-based database change management"+4. **Approval Workflow**: Show review and approval process+ - Caption: "Custom approval workflows for compliance"+5. **Audit Trail**: Show change history+ - Caption: "Complete audit trail of all database changes"++**Videos (Optional - Up to 4)**:+- YouTube or Vimeo links+- Include thumbnail (1280x720 pixels)+- Examples:+ - Product overview (2-3 minutes)+ - Getting started tutorial+ - Feature deep dives++### Additional Links (Optional)++- `https://www.bytebase.com/docs` (Documentation)+- `https://github.com/bytebase/bytebase` (GitHub)+- `https://www.bytebase.com/pricing` (Pricing)++5. Click **"Save draft"**++---++## Part 5: Preview Audience (2 minutes)++Click on **"Preview audience"** tab.++Add Azure subscription IDs that can access your offer before it goes live:++1. **Azure subscription ID**: Your test subscription ID+ - Format: `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`+ - Find this in Azure Portal → Subscriptions++2. **Description**: `Internal testing`++3. Click **"+ Add subscription ID"** to add more if needed++4. Click **"Save draft"**++---++## Part 6: Technical Configuration (10 minutes)++Click on **"Technical configuration"** tab.++This is where you link your CNAB bundle.++### Cluster Type++1. **Select cluster type**:+ - ☑ **Azure Kubernetes Service managed cluster**+ - ☐ Azure Arc-enabled Kubernetes cluster++### Kubernetes Application Package++1. **Package type**: Select `CNAB`++2. **Package location**:+ ```+ bytebase.azurecr.io/bytebase:3.11.1+ ```+ - This is your CNAB bundle path from Step 5 of README.md+ - Format: `<acr-name>.azurecr.io/<repository>:<tag>`+ - **Important**: Must be in CNAB/OCI format (not Docker v2 manifest)++3. **Grant access**:+ - Click **"Grant access"**+ - This allows Microsoft to access your ACR to copy images+ - Follow the prompts to authorize++### Application Insights (Optional)++- If you want telemetry, configure Application Insights+- For now, you can skip this++4. Click **"Save draft"**++---++## Part 7: Plan Overview - Create Plans (15 minutes)++Click on **"Plan overview"** tab.++You must create at least one plan. Let's create a BYOL plan:++### Create BYOL Plan++1. Click **"+ Create new plan"**++2. **Plan ID**: `bytebase-byol`+ - Permanent, cannot be changed+ - Lowercase, no spaces++3. **Plan name**: `Bytebase BYOL`+ - Display name customers see+ - Can be changed later++4. Click **"Create"**++### Configure the Plan++You'll see tabs for the plan:++#### Plan Setup Tab++1. **Azure regions**: Default is all regions (recommended)++2. **Plan type**: Select `BYOL (Bring Your Own License)`++3. **Visibility**:+ - ◉ **Public** (recommended for launch)+ - ○ Private (only for specific customers)++4. Click **"Save draft"**++#### Plan Listing Tab++1. **Plan name**: `Bytebase BYOL`++2. **Plan summary** (100 characters):+ ```+ Bring your own Bytebase license and deploy to your AKS cluster+ ```++3. **Plan description** (2000 characters):+ ```markdown+ ## Bytebase BYOL Plan++ Deploy Bytebase to your Azure Kubernetes Service (AKS) cluster with your own Bytebase license.++ ### What's Included++ - Full Bytebase application deployment via Helm+ - Deploy to your AKS cluster+ - Persistent storage configuration+ - External PostgreSQL database integration+ - ConfigureConfigurable resource limits++ ### Requirements++ - Active Bytebase license (purchase separately from bytebase.com)+ - Azure Kubernetes Service (AKS) cluster+ - External PostgreSQL database for metadata storage+ - Minimum 2 vCPU and 4GB RAM recommended++ ### License Information++ You must purchase a Bytebase license separately. Visit https://www.bytebase.com/pricing for license options and pricing.++ Contact [email protected] for enterprise licensing or questions.++ ### Support++ - Documentation: https://docs.bytebase.com+ - Community Support: https://github.com/bytebase/bytebase+ - Enterprise Support: [email protected]+ ```++4. Click **"Save draft"**++#### Pricing and Availability Tab++1. **Markets**:+ - Select all markets OR specific countries/regions+ - Recommended: **All markets**++2. **Pricing**:+ - BYOL has no marketplace pricing+ - Customers pay you directly for licenses++3. **Free trial**: Not applicable for BYOL++4. Click **"Save draft"**++#### Technical Configuration Tab (Plan-specific)++1. **Application version**: `3.11.1` (matches your Bytebase version)++2. **Package reference**: Should auto-populate from offer-level technical config++3. **Configuration settings** (optional):+ - You can override Helm values per plan+ - For BYOL, defaults are usually fine++4. Click **"Save draft"**++---++## Part 8: Co-sell with Microsoft (Optional - 10 minutes)++Click on **"Co-sell with Microsoft"** tab.++This is optional but recommended for increased visibility.++### Documents++1. **Upload co-sell documents**:+ - Solution overview (PDF)+ - Reference architecture diagram+ - Customer success stories++### Solution Areas++Select relevant areas:+- ☑ Application Development+- ☑ Data and AI+- ☑ DevOps++2. Click **"Save draft"**++---++## Part 9: Resell through CSPs (Optional - 2 minutes)++Click on **"Resell through CSPs"** tab.++Allow Cloud Solution Providers to resell your offer:++1. **CSP channel**:+ - ◉ No partners in the CSP program+ - ○ Any partner in the CSP program+ - ○ Specific partners in the CSP program++2. For wider reach, select **"Any partner in the CSP program"**++3. Click **"Save draft"**++---++## Part 10: Review and Publish (5 minutes)++### Final Review++1. Go through each tab and ensure all required fields are filled:+ - ✅ Offer setup+ - ✅ Properties+ - ✅ Offer listing+ - ✅ Preview audience+ - ✅ Technical configuration+ - ✅ Plan overview (at least 1 plan)++2. Look for any red warnings or missing fields++### Publish to Preview++1. Click **"Review and publish"** button (top right)++2. Review the submission checklist++3. Click **"Publish"**++4. Confirmation:+ ```+ Your offer has been submitted for publishing.+ Status: Publisher signoff (Preview)+ ```++### What Happens Next++**Phase 1: Publisher Signoff (Preview)** - 1-2 hours+- Microsoft validates your submission+- Your offer becomes available to preview audience+- Test your offer deployment++**Phase 2: Publisher Approval** - You must approve+- Test the preview version+- Deploy to your test AKS cluster+- Verify everything works+- Click **"Go live"** when ready++**Phase 3: Certification** - 2-4 weeks+- Microsoft security scanning+- Image vulnerability assessment+- Metadata review+- Deployment testing++**Phase 4: Live on Marketplace** - Automatic+- Once certified, offer goes live+- Available to all Azure customers+- Appears in search results++---++## Testing Your Preview Offer++Once in preview status:++1. **Access the preview**:+ - Use an Azure subscription you added to preview audience+ - Go to: https://portal.azure.com/#create/+ - Search for your offer (may take an hour to appear)++2. **Deploy to test AKS**:+ - Follow the deployment wizard+ - Configure PostgreSQL connection+ - Deploy to test namespace++3. **Verify functionality**:+ - Check pods are running: `kubectl get pods -n bytebase`+ - Access Bytebase UI via external URL+ - Test database connections+ - Verify license activation (BYOL)++4. **If issues found**:+ - Return to Partner Center+ - Update configuration+ - Re-submit for review++5. **When ready**:+ - Click **"Go live"** in Partner Center+ - Offer proceeds to certification++---++## Common Issues and Solutions++### Issue: "Package location not accessible"+**Solution**: Ensure you ran `az acr login` and granted Partner Center access to your ACR++### Issue: "Invalid CNAB bundle"+**Solution**:+- Re-run `./scripts/azure-marketplace/package.sh`+- Ensure `cpa verify` passes without errors+- Check manifest.yaml references correct images++### Issue: "Missing required screenshots"+**Solution**: Upload at least one screenshot (1280x720 or 1920x1080 PNG)++### Issue: "Legal document URL not accessible"+**Solution**: Ensure privacy policy and terms URLs are publicly accessible (200 OK response)++### Issue: "Plan pricing configuration invalid"+**Solution**: For BYOL, ensure no pricing meters are configured++---++## After Going Live++### Monitor Performance++1. **Analytics Dashboard**:+ - Partner Center → Commercial Marketplace → Analyze+ - Track page visits, deployments, revenue++2. **Customer Feedback**:+ - Monitor ratings and reviews+ - Respond to customer questions++3. **Support Tickets**:+ - Set up support process for marketplace customers+ - Track common issues++### Updating Your Offer++**To release new versions**:++1. Build new Docker image with updated version tag+2. Push to ACR+3. Run packaging tool with new version+4. In Partner Center:+ - Update Technical Configuration with new CNAB path+ - Update plan versions+ - Add changelog in description+5. Re-submit for certification++**Typical update timeline**: 1-2 weeks for re-certification++---++## Checklist++Before clicking "Review and publish", verify:++- [ ] Offer setup complete+- [ ] Properties configured (categories, legal)+- [ ] Offer listing complete (description, screenshots, logo)+- [ ] Preview audience added (at least one subscription)+- [ ] Technical configuration (CNAB bundle path, ACR access granted)+- [ ] At least one plan created and configured+- [ ] Plan description and pricing configured+- [ ] All required fields filled (no red warnings)+- [ ] Legal documents (privacy, terms) are publicly accessible+- [ ] Support contact information is correct++---++## Support++- **Partner Center Help**: https://partner.microsoft.com/support+- **Documentation**: https://learn.microsoft.com/en-us/partner-center/marketplace-offers/+- **Open a support ticket**: Partner Center → Support → New request++---++**Ready to publish?** Follow this guide step by step and you'll have your offer live on Azure Marketplace in about 4 weeks! 🚀diff --git a/scripts/azure-marketplace/README.md b/scripts/azure-marketplace/README.mdnew file mode 100644index 0000000000..c08687fc50--- /dev/null+++ b/scripts/azure-marketplace/README.md@@ -0,0 +1,440 @@+# Publishing Bytebase to Azure Marketplace++This guide walks you through publishing Bytebase as an Azure Container Offer on Azure Marketplace.++## Prerequisites++1. **Azure Account Setup**+ - Active Azure subscription+ - Partner Center account with publisher access+ - Azure Container Registry (ACR) in your publishing tenant++2. **Technical Requirements**+ - Docker installed locally+ - Azure CLI installed and configured+ - Access to push images to your ACR+ - Kubernetes knowledge (for testing)++3. **Tools**+ - Microsoft's container-package-app tool (Docker image)++## Directory Structure++```+bytebase/+├── scripts/azure-marketplace/+│ ├── manifest.yaml # Package metadata+│ ├── createUiDefinition.json # Azure portal deployment UI+│ ├── mainTemplate.json # ARM template for deployment+│ ├── values-azure.yaml # Azure-specific Helm values+│ └── README.md # This file+├── helm-charts/bytebase/ # Your existing Helm chart+│ ├── Chart.yaml+│ ├── values.yaml+│ └── templates/+│ ├── statefulset.yaml # Needs modification (see below)+│ └── ...+└── scripts/+ └── Dockerfile # Your existing Dockerfile+```++## Step-by-Step Publishing Guide++### Step 1: Modify Helm Chart for Azure Marketplace++Azure Marketplace requires images to use the `global.azure.images` pattern. You need to update your `helm-charts/bytebase/templates/statefulset.yaml` file.++#### Current Image Reference (Line 114-119):+```yaml+{{- if $registryMirrorHost }}+image: {{ trimSuffix "/" $registryMirrorHost }}/bytebase/bytebase:{{ $version }}+{{- else }}+image: bytebase/bytebase:{{ $version }}+{{- end }}+```++#### Updated Image Reference (Add Azure support):+```yaml+{{- if .Values.global.azure.images.bytebase }}+# Azure Marketplace image path+image: {{ .Values.global.azure.images.bytebase.registry }}/{{ .Values.global.azure.images.bytebase.repository }}:{{ .Values.global.azure.images.bytebase.tag }}+{{- else if $registryMirrorHost }}+# Registry mirror path+image: {{ trimSuffix "/" $registryMirrorHost }}/bytebase/bytebase:{{ $version }}+{{- else }}+# Default Docker Hub path+image: bytebase/bytebase:{{ $version }}+{{- end }}+```++This change allows Azure Marketplace to retag and host images in their registry while maintaining backward compatibility with existing deployments.++### Step 2: Set Up Azure Container Registry++```bash+# Login to Azure+az login++# Create resource group (if needed)+az group create --name bytebase-marketplace --location eastus++# Create Azure Container Registry+az acr create \+ --resource-group bytebase-marketplace \+ --name bytebaseacr \+ --sku Premium \+ --location eastus++# Login to ACR+az acr login --name bytebaseacr++# Get ACR login server+ACR_LOGIN_SERVER=$(az acr show --name bytebaseacr --query loginServer --output tsv)+echo "ACR Login Server: $ACR_LOGIN_SERVER"+```++### Step 3: Push Bytebase Image to ACR++You have two options: use the official Bytebase image from Docker Hub, or build your own.++#### Option A: Use Official Image (Recommended)++```bash+# Pull the official Bytebase image+docker pull bytebase/bytebase:3.11.1++# Tag for ACR+docker tag bytebase/bytebase:3.11.1 $ACR_LOGIN_SERVER/bytebase/bytebase:3.11.1++# Push to ACR+docker push $ACR_LOGIN_SERVER/bytebase/bytebase:3.11.1+```++#### Option B: Build From Source++```bash+# From the root of your repository+cd /Users/ecmadao/Develop/Bytebase/ecmadao/bytebase++# Build the Docker image+docker build -f scripts/Dockerfile -t bytebase/bytebase:3.11.1 .++# Tag for ACR+docker tag bytebase/bytebase:3.11.1 $ACR_LOGIN_SERVER/bytebase/bytebase:3.11.1++# Push to ACR+docker push $ACR_LOGIN_SERVER/bytebase/bytebase:3.11.1+```++**Automated Script:**+```bash+./scripts/azure-marketplace/push-to-acr.sh+```++### Step 4: Update manifest.yaml with Your ACR++Edit `scripts/azure-marketplace/manifest.yaml` and update the registry and image references:++```yaml+registries:+ - name: <your-acr-name>.azurecr.io+ url: <your-acr-name>.azurecr.io++images:+ - image: <your-acr-name>.azurecr.io/bytebase/bytebase:3.11.1+ platform: linux/amd64+```++### Step 5: Build and Publish CNAB Bundle++The CNAB bundle must be built and published by Microsoft's CPA tool to ensure proper OCI artifact format.++#### Automated Script (Recommended):++```bash+cd azure-marketplace+./package.sh+```++This script will:+1. Validate all artifacts with `cpa verify`+2. Optionally build and publish the CNAB bundle with `cpa buildbundle`++#### Manual Process:++**Step 5a: Verify artifacts**++```bash+cd /Users/ecmadao/Develop/Bytebase/ecmadao/bytebase++docker run --rm \+ -v /var/run/docker.sock:/var/run/docker.sock \+ -v $(pwd):/data \+ -w /data/azure-marketplace \+ mcr.microsoft.com/container-package-app:latest \+ cpa verify+```++**Step 5b: Build and publish CNAB bundle**++**IMPORTANT:** The CPA tool needs Azure CLI authentication to push to ACR. You must mount your Azure credentials:++```bash+# Ensure you're logged in to Azure+az login+az acr login --name <your-acr-name>++# Run CPA with Azure credentials mounted+docker run --rm \+ -v /var/run/docker.sock:/var/run/docker.sock \+ -v $(pwd)/..:/data \+ -v $HOME/.azure:/root/.azure \+ -w /data/azure-marketplace \+ mcr.microsoft.com/container-package-app:latest \+ /bin/bash -c "az acr login --name <your-acr-name> && cpa buildbundle --force"+```++**What this does:**+- Packages Helm chart + ARM template + UI definition into a CNAB bundle+- Creates Porter invocation images with proper OCI annotations+- Publishes to ACR with CNAB-compliant manifest format (required by Partner Center)+- Tags bundle as `<your-acr-name>.azurecr.io/bytebase:3.11.1`++**Verify the bundle:**++```bash+# Check the bundle manifest has proper CNAB annotations+az acr manifest show --registry <your-acr-name> --name bytebase:3.11.1 | grep "io.cnab"+```++You should see annotations like:+- `io.cnab.runtime_version: 1.2.0`+- `org.opencontainers.artifactType: application/vnd.cnab.manifest.v1`++**Troubleshooting:**++Common authentication issues include:+- CPA tool cannot access Docker credentials+- Azure CLI session not properly mounted+- ACR permissions not configured correctly++The key is that the CPA tool itself must push the bundle - manual `docker push` will not create the proper CNAB/OCI artifact format that Partner Center requires.++### Step 6: Test Your createUiDefinition++Before submitting to Partner Center, test your deployment UI:++1. Go to Azure Portal CreateUI Sandbox:+ https://portal.azure.com/#blade/Microsoft_Azure_CreateUIDef/SandboxBlade++2. Copy the contents of `scripts/azure-marketplace/createUiDefinition.json`++3. Paste and test the UI flow++4. Verify all fields, validations, and outputs work correctly++### Step 7: Create Partner Center Offer++For detailed, step-by-step instructions on creating your Partner Center offer, see:++📖 **[PARTNER_CENTER_GUIDE.md](./PARTNER_CENTER_GUIDE.md)** - Complete walkthrough with field-by-field instructions++**Quick Overview:**++1. **Access Partner Center**: https://partner.microsoft.com/dashboard+2. **Create Offer**: Commercial Marketplace → New Offer → Azure Container+3. **Offer ID**: `bytebase` (permanent, must be unique)+4. **Configure Sections**:+ - Offer Properties (categories, legal documents)+ - Offer Listing (description, screenshots, logo)+ - Preview Audience (test subscription IDs)+ - **Technical Configuration**: `<your-acr-name>.azurecr.io/bytebase:3.11.1`+ - Plans (create at least one - BYOL recommended for initial launch)+5. **Review and Publish**: Submit for certification++**Required Materials:**+- Legal documents (Privacy Policy, Terms of Service URLs)+- Logo files (48x48, 90x90, 216x216, 255x115 PNG)+- Screenshots (at least 1, max 5, 1280x720 or 1920x1080 PNG)+- Support contact information++**Timeline:** 2-4 weeks for Microsoft certification after submission++### Step 8: Submit for Certification++1. **Review and Submit**+ - Review all sections in Partner Center+ - Click "Review and publish"+ - Submit for certification++2. **Certification Process**+ - Microsoft performs security scanning on your images+ - Reviews all marketplace metadata+ - Tests deployment flow+ - **Timeline**: Typically 2-4 weeks++3. **Address Feedback**+ - Microsoft may request changes+ - Address any security vulnerabilities+ - Update and resubmit as needed++### Step 9: Publish++Once certification passes:+1. Approve the preview version+2. Click "Go live"+3. Your offer becomes available on Azure Marketplace!++## Testing Your Deployment++Before submitting, test locally:++```bash+# Install your Helm chart with Azure values+helm install bytebase-test ./helm-charts/bytebase \+ -f scripts/azure-marketplace/values-azure.yaml \+ --set bytebase.option.externalPg.url="postgresql://user:pass@host:5432/db" \+ --set bytebase.option.external-url="https://test.example.com" \+ --namespace bytebase \+ --create-namespace++# Verify deployment+kubectl get pods -n bytebase+kubectl logs -n bytebase -l app=bytebase++# Clean up+helm uninstall bytebase-test -n bytebase+```++## Pricing Strategy Considerations++### BYOL (Recommended for Initial Launch)+**Pros:**+- Faster to market (simpler implementation)+- Full control over pricing and billing+- No Azure Metering API integration needed+- Flexible pricing changes++**Cons:**+- Separate billing (not on Azure invoice)+- Requires your own license management system++### Marketplace Metered Billing+**Pros:**+- Unified Azure billing (appears on customer's Azure invoice)+- Azure handles payment processing+- Builds trust with enterprise customers++**Cons:**+- Requires Azure Metering API integration in your application+- More complex to implement and test+- Longer certification process++## Marketplace Revenue Share++Microsoft takes a commission on marketplace transactions:+- **Standard**: ~20% for transactable offers+- **IP co-sell eligible**: ~3% (requires co-sell setup)++BYOL offers still have a marketplace fee (~3%) for listing.++## Updating Your Offer++After publishing, to release new versions:++1. Build new Docker image with updated version tag+2. Push to ACR+3. Update `manifest.yaml` with new version+4. Run `cpa buildbundle` to create new CNAB+5. In Partner Center:+ - Update Technical Configuration with new CNAB path+ - Increment plan version+ - Submit for re-certification++## Important: CNAB Bundle Format++**Critical Requirement:** Partner Center requires CNAB bundles in proper OCI artifact format, not regular Docker v2 manifests.++**What This Means:**+- ✅ Bundle must be published by CPA tool (`cpa buildbundle`)+- ❌ Manual `docker push` will NOT work (creates wrong manifest type)+- ✅ Bundle must have OCI annotations like `io.cnab.runtime_version` and `org.opencontainers.artifactType`++**How to Verify:**+```bash+# Check your bundle format+az acr manifest show --registry <your-acr-name> --name bytebase:3.11.1++# Should show:+# - annotations.io.cnab.runtime_version: "1.2.0"+# - annotations.org.opencontainers.artifactType: "application/vnd.cnab.manifest.v1"+# - mediaType: "application/vnd.oci.image.manifest.v1+json" (for manifests)+```++If your bundle shows `mediaType: "application/vnd.docker.distribution.manifest.v2+json"` instead, it was pushed incorrectly and Partner Center will reject it with error: *"The artifact you selected is not a valid Cloud Native Application Bundle (CNAB)"*++**Solution:** Delete the incorrect bundle and republish using the CPA tool with Azure CLI authentication as described in Step 5b.++## Common Issues and Solutions++### Issue 1: Partner Center Rejects Bundle+**Problem**: Error "The artifact you selected is not a valid Cloud Native Application Bundle (CNAB)"+**Solution**:+- Verify bundle format with `az acr manifest show` command+- If incorrect format, republish using CPA tool (not docker push)+- Follow Step 5b instructions for proper authentication++### Issue 2: Image Pull Errors+**Problem**: ACR images can't be pulled during packaging+**Solution**: Ensure you're logged into ACR: `az acr login --name <acr-name>`++### Issue 3: CPA Authentication Failures+**Problem**: `cpa buildbundle` fails with authentication errors+**Solution**:+- Ensure Azure CLI is logged in: `az login`+- Login to ACR: `az acr login --name <acr-name>`+- Mount Azure credentials when running CPA: `-v $HOME/.azure:/root/.azure`+- See Step 5b for complete command++### Issue 4: Validation Failures+**Problem**: `cpa verify` fails with Helm chart errors+**Solution**:+- Ensure Helm chart is unpacked (not .tgz)+- Verify `Chart.yaml` apiVersion is v2+- Check all template references are valid++### Issue 5: createUiDefinition Errors+**Problem**: UI definition doesn't load in sandbox+**Solution**:+- Validate JSON syntax+- Check all parameter references match ARM template+- Test incrementally (comment out sections to isolate issues)++### Issue 6: Security Scan Failures+**Problem**: Certification blocked by vulnerability scan+**Solution**:+- Update base images in Dockerfile+- Run `docker scan` locally before submitting+- Address all HIGH and CRITICAL vulnerabilities++## Support and Resources++- **Azure Marketplace Docs**: https://learn.microsoft.com/en-us/partner-center/marketplace-offers/marketplace-containers+- **Mastering the Marketplace**: https://microsoft.github.io/Mastering-the-Marketplace/container/+- **CreateUI Sandbox**: https://portal.azure.com/#blade/Microsoft_Azure_CreateUIDef/SandboxBlade+- **Partner Center**: https://partner.microsoft.com/dashboard+- **Microsoft Support**: Open a ticket through Partner Center++## Next Steps++1. ✅ Modify Helm chart statefulset.yaml (Step 1)+2. ✅ Set up Azure Container Registry (Step 2)+3. ✅ Build and push Docker image (Step 3)+4. ✅ Update manifest.yaml with your ACR (Step 4)+5. ✅ Package application with cpa tool (Step 5)+6. ✅ Test createUiDefinition in sandbox (Step 6)+7. ✅ Create Partner Center offer (Step 7)+8. ✅ Submit for certification (Step 8)+9. ✅ Publish to Azure Marketplace (Step 9)++Good luck with your Azure Marketplace launch! 🚀diff --git a/scripts/azure-marketplace/createUiDefinition.json b/scripts/azure-marketplace/createUiDefinition.jsonnew file mode 100644index 0000000000..66c2b9f04e--- /dev/null+++ b/scripts/azure-marketplace/createUiDefinition.json@@ -0,0 +1,293 @@+{+ "$schema": "https://schema.management.azure.com/schemas/0.1.2-preview/CreateUIDefinition.MultiVm.json#",+ "handler": "Microsoft.Azure.CreateUIDef",+ "version": "0.1.2-preview",+ "parameters": {+ "config": {+ "isWizard": false,+ "basics": {+ "description": "Bytebase is a database CI/CD tool for DevOps teams. Deploy Bytebase to your Azure Kubernetes Service cluster to manage database schema changes safely and efficiently.",+ "location": {+ "label": "Location",+ "toolTip": "Azure region for deployment",+ "resourceTypes": [+ "Microsoft.ContainerService/managedClusters"+ ]+ },+ "resourceGroup": {+ "allowExisting": true+ }+ }+ },+ "basics": [+ {+ "name": "clusterLookupControl",+ "type": "Microsoft.Solutions.ArmApiControl",+ "request": {+ "method": "GET",+ "path": "[concat(subscription().id, '/resourcegroups/', resourceGroup().name, '/providers/Microsoft.ContainerService/managedClusters?api-version=2024-01-01')]"+ }+ },+ {+ "name": "cluster",+ "type": "Microsoft.Common.DropDown",+ "label": "AKS Cluster",+ "toolTip": "Select the Azure Kubernetes Service cluster where Bytebase will be deployed",+ "constraints": {+ "allowedValues": "[map(steps('basics').clusterLookupControl.value, (item) => parse(concat('{\"label\":\"', item.name, '\",\"value\":\"', item.id, '\"}')))]",+ "required": true+ },+ "visible": true+ }+ ],+ "steps": [+ {+ "name": "bytebaseConfig",+ "label": "Bytebase Configuration",+ "elements": [+ {+ "name": "namespace",+ "type": "Microsoft.Common.TextBox",+ "label": "Kubernetes Namespace",+ "defaultValue": "bytebase",+ "toolTip": "The Kubernetes namespace where Bytebase will be deployed",+ "constraints": {+ "required": true,+ "regex": "^[a-z0-9]([-a-z0-9]{0,61}[a-z0-9])?$",+ "validationMessage": "Namespace must consist of lowercase alphanumeric characters or '-', start and end with alphanumeric character, and be 1-63 characters long"+ },+ "visible": true+ },+ {+ "name": "port",+ "type": "Microsoft.Common.TextBox",+ "label": "Bytebase Port",+ "defaultValue": "8080",+ "toolTip": "Port where Bytebase server will run",+ "constraints": {+ "required": true,+ "regex": "^([1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$",+ "validationMessage": "Port must be a valid number between 1 and 65535"+ },+ "visible": true+ },+ {+ "name": "externalUrl",+ "type": "Microsoft.Common.TextBox",+ "label": "External URL",+ "defaultValue": "",+ "toolTip": "The external URL where users will access Bytebase (e.g., https://bytebase.example.com)",+ "placeholder": "https://bytebase.example.com",+ "constraints": {+ "required": true,+ "regex": "^https?://[a-zA-Z0-9][-a-zA-Z0-9.]{0,253}[a-zA-Z0-9](:[0-9]{1,5})?(/.*)?$",+ "validationMessage": "Must be a valid HTTP or HTTPS URL (max 256 characters)"+ },+ "visible": true+ },+ {+ "name": "version",+ "type": "Microsoft.Common.TextBox",+ "label": "Bytebase Version",+ "defaultValue": "3.11.1",+ "toolTip": "Bytebase version to deploy",+ "constraints": {+ "required": true,+ "regex": "^[0-9]+\\.[0-9]+\\.[0-9]+$",+ "validationMessage": "Version must be in format X.Y.Z (e.g., 3.11.1)"+ },+ "visible": true+ }+ ]+ },+ {+ "name": "databaseConfig",+ "label": "Database Configuration",+ "elements": [+ {+ "name": "databaseInfo",+ "type": "Microsoft.Common.InfoBox",+ "visible": true,+ "options": {+ "icon": "Info",+ "text": "Bytebase requires an external PostgreSQL database to store metadata. You can provide either a connection string or individual connection parameters."+ }+ },+ {+ "name": "pgConnectionType",+ "type": "Microsoft.Common.OptionsGroup",+ "label": "PostgreSQL Connection Type",+ "defaultValue": "Connection String",+ "toolTip": "Choose how to specify PostgreSQL connection details",+ "constraints": {+ "allowedValues": [+ {+ "label": "Connection String",+ "value": "connectionString"+ },+ {+ "label": "Individual Parameters",+ "value": "parameters"+ }+ ],+ "required": true+ },+ "visible": true+ },+ {+ "name": "pgUrl",+ "type": "Microsoft.Common.TextBox",+ "label": "PostgreSQL Connection String",+ "defaultValue": "",+ "toolTip": "PostgreSQL connection string (e.g., postgresql://user:password@host:5432/database)",+ "placeholder": "postgresql://user:password@host:5432/database",+ "constraints": {+ "required": "[equals(steps('databaseConfig').pgConnectionType, 'connectionString')]",+ "regex": "^postgresql://[^:]+:[^@]+@[a-zA-Z0-9.-]+(:[0-9]+)?/[a-zA-Z0-9_-]+$",+ "validationMessage": "Must be a valid PostgreSQL connection string"+ },+ "visible": "[equals(steps('databaseConfig').pgConnectionType, 'connectionString')]"+ },+ {+ "name": "pgHost",+ "type": "Microsoft.Common.TextBox",+ "label": "PostgreSQL Host",+ "defaultValue": "",+ "toolTip": "PostgreSQL server hostname or IP address",+ "constraints": {+ "required": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]",+ "regex": "^[a-zA-Z0-9][-a-zA-Z0-9.]{0,253}[a-zA-Z0-9]$",+ "validationMessage": "Must be a valid hostname or IP address (max 255 characters)"+ },+ "visible": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]"+ },+ {+ "name": "pgPort",+ "type": "Microsoft.Common.TextBox",+ "label": "PostgreSQL Port",+ "defaultValue": "5432",+ "toolTip": "PostgreSQL server port",+ "constraints": {+ "required": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]",+ "regex": "^([1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$",+ "validationMessage": "Port must be a valid number between 1 and 65535"+ },+ "visible": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]"+ },+ {+ "name": "pgUsername",+ "type": "Microsoft.Common.TextBox",+ "label": "PostgreSQL Username",+ "defaultValue": "",+ "toolTip": "PostgreSQL username",+ "constraints": {+ "required": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]",+ "regex": "^[a-zA-Z0-9_]{1,63}$",+ "validationMessage": "Username must be 1-63 characters, alphanumeric or underscore"+ },+ "visible": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]"+ },+ {+ "name": "pgPassword",+ "type": "Microsoft.Common.PasswordBox",+ "label": {+ "password": "PostgreSQL Password",+ "confirmPassword": "Confirm Password"+ },+ "toolTip": "PostgreSQL password",+ "constraints": {+ "required": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]"+ },+ "options": {+ "hideConfirmation": false+ },+ "visible": "[equals(steps('databaseConfig').pgConnectionType', 'parameters')]"+ },+ {+ "name": "pgDatabase",+ "type": "Microsoft.Common.TextBox",+ "label": "PostgreSQL Database",+ "defaultValue": "bytebase",+ "toolTip": "PostgreSQL database name",+ "constraints": {+ "required": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]",+ "regex": "^[a-zA-Z0-9_]{1,63}$",+ "validationMessage": "Database name must be 1-63 characters, alphanumeric or underscore"+ },+ "visible": "[equals(steps('databaseConfig').pgConnectionType, 'parameters')]"+ }+ ]+ },+ {+ "name": "storageConfig",+ "label": "Storage Configuration",+ "elements": [+ {+ "name": "persistenceEnabled",+ "type": "Microsoft.Common.OptionsGroup",+ "label": "Enable Persistent Storage",+ "defaultValue": "Yes",+ "toolTip": "Enable persistent storage for Bytebase data",+ "constraints": {+ "allowedValues": [+ {+ "label": "Yes",+ "value": "true"+ },+ {+ "label": "No",+ "value": "false"+ }+ ],+ "required": true+ },+ "visible": true+ },+ {+ "name": "storageSize",+ "type": "Microsoft.Common.TextBox",+ "label": "Storage Size",+ "defaultValue": "10Gi",+ "toolTip": "Size of persistent volume (e.g., 10Gi, 20Gi)",+ "constraints": {+ "required": "[equals(steps('storageConfig').persistenceEnabled, 'true')]",+ "regex": "^[0-9]{1,5}(Gi|Mi|Ti)$",+ "validationMessage": "Must be a valid size with unit: 1-99999 followed by Gi, Mi, or Ti (e.g., 10Gi, 1Ti)"+ },+ "visible": "[equals(steps('storageConfig').persistenceEnabled, 'true')]"+ },+ {+ "name": "storageClass",+ "type": "Microsoft.Common.TextBox",+ "label": "Storage Class",+ "defaultValue": "",+ "toolTip": "Kubernetes storage class for persistent volume (leave empty for default)",+ "constraints": {+ "required": false,+ "regex": "^$|^[a-z0-9]([-a-z0-9]{0,251}[a-z0-9])?$",+ "validationMessage": "Storage class must be empty or 1-253 characters of lowercase alphanumeric or '-'"+ },+ "visible": "[equals(steps('storageConfig').persistenceEnabled, 'true')]"+ }+ ]+ }+ ],+ "outputs": {+ "clusterResourceId": "[basics('cluster')]",+ "namespace": "[steps('bytebaseConfig').namespace]",+ "bytebasePort": "[steps('bytebaseConfig').port]",+ "bytebaseExternalUrl": "[steps('bytebaseConfig').externalUrl]",+ "bytebaseVersion": "[steps('bytebaseConfig').version]",+ "pgConnectionType": "[steps('databaseConfig').pgConnectionType]",+ "pgUrl": "[if(equals(steps('databaseConfig').pgConnectionType, 'connectionString'), steps('databaseConfig').pgUrl, '')]",+ "pgHost": "[if(equals(steps('databaseConfig').pgConnectionType, 'parameters'), steps('databaseConfig').pgHost, '')]",+ "pgPort": "[if(equals(steps('databaseConfig').pgConnectionType, 'parameters'), steps('databaseConfig').pgPort, '')]",+ "pgUsername": "[if(equals(steps('databaseConfig').pgConnectionType, 'parameters'), steps('databaseConfig').pgUsername, '')]",+ "pgPassword": "[if(equals(steps('databaseConfig').pgConnectionType, 'parameters'), steps('databaseConfig').pgPassword, '')]",+ "pgDatabase": "[if(equals(steps('databaseConfig').pgConnectionType, 'parameters'), steps('databaseConfig').pgDatabase, '')]",+ "persistenceEnabled": "[steps('storageConfig').persistenceEnabled]",+ "storageSize": "[if(equals(steps('storageConfig').persistenceEnabled, 'true'), steps('storageConfig').storageSize, '')]",+ "storageClass": "[if(equals(steps('storageConfig').persistenceEnabled, 'true'), steps('storageConfig').storageClass, '')]"+ }+ }+}diff --git a/scripts/azure-marketplace/mainTemplate.json b/scripts/azure-marketplace/mainTemplate.jsonnew file mode 100644index 0000000000..42f2af472b--- /dev/null+++ b/scripts/azure-marketplace/mainTemplate.json@@ -0,0 +1,175 @@+{+ "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",+ "contentVersion": "1.0.0.0",+ "parameters": {+ "clusterResourceId": {+ "type": "string",+ "metadata": {+ "description": "Resource ID of the AKS cluster"+ }+ },+ "namespace": {+ "type": "string",+ "defaultValue": "bytebase",+ "metadata": {+ "description": "Kubernetes namespace for Bytebase deployment"+ }+ },+ "bytebasePort": {+ "type": "string",+ "defaultValue": "8080",+ "metadata": {+ "description": "Port for Bytebase server"+ }+ },+ "bytebaseExternalUrl": {+ "type": "string",+ "metadata": {+ "description": "External URL for accessing Bytebase"+ }+ },+ "bytebaseVersion": {+ "type": "string",+ "defaultValue": "3.11.1",+ "metadata": {+ "description": "Bytebase version to deploy"+ }+ },+ "pgConnectionType": {+ "type": "string",+ "defaultValue": "connectionString",+ "allowedValues": [+ "connectionString",+ "parameters"+ ],+ "metadata": {+ "description": "Type of PostgreSQL connection configuration"+ }+ },+ "pgUrl": {+ "type": "securestring",+ "defaultValue": "",+ "metadata": {+ "description": "PostgreSQL connection string"+ }+ },+ "pgHost": {+ "type": "string",+ "defaultValue": "",+ "metadata": {+ "description": "PostgreSQL host"+ }+ },+ "pgPort": {+ "type": "string",+ "defaultValue": "5432",+ "metadata": {+ "description": "PostgreSQL port"+ }+ },+ "pgUsername": {+ "type": "string",+ "defaultValue": "",+ "metadata": {+ "description": "PostgreSQL username"+ }+ },+ "pgPassword": {+ "type": "securestring",+ "defaultValue": "",+ "metadata": {+ "description": "PostgreSQL password"+ }+ },+ "pgDatabase": {+ "type": "string",+ "defaultValue": "bytebase",+ "metadata": {+ "description": "PostgreSQL database name"+ }+ },+ "persistenceEnabled": {+ "type": "string",+ "defaultValue": "true",+ "allowedValues": [+ "true",+ "false"+ ],+ "metadata": {+ "description": "Enable persistent storage"+ }+ },+ "storageSize": {+ "type": "string",+ "defaultValue": "10Gi",+ "metadata": {+ "description": "Size of persistent volume"+ }+ },+ "storageClass": {+ "type": "string",+ "defaultValue": "",+ "metadata": {+ "description": "Kubernetes storage class"+ }+ }+ },+ "variables": {+ "clusterName": "[last(split(parameters('clusterResourceId'), '/'))]",+ "extensionName": "bytebase",+ "pgUrlValue": "[if(equals(parameters('pgConnectionType'), 'connectionString'), parameters('pgUrl'), concat('postgresql://', parameters('pgUsername'), ':', parameters('pgPassword'), '@', parameters('pgHost'), ':', parameters('pgPort'), '/', parameters('pgDatabase')))]",+ "plan-name": "DONOTMODIFY",+ "plan-publisher": "DONOTMODIFY",+ "plan-offerID": "DONOTMODIFY",+ "releaseTrain": "DONOTMODIFY",+ "clusterExtensionTypeName": "DONOTMODIFY"+ },+ "resources": [+ {+ "type": "Microsoft.KubernetesConfiguration/extensions",+ "apiVersion": "2023-05-01",+ "name": "[variables('extensionName')]",+ "scope": "[parameters('clusterResourceId')]",+ "properties": {+ "extensionType": "[variables('clusterExtensionTypeName')]",+ "autoUpgradeMinorVersion": true,+ "releaseTrain": "[variables('releaseTrain')]",+ "plan": {+ "name": "[variables('plan-name')]",+ "publisher": "[variables('plan-publisher')]",+ "product": "[variables('plan-offerID')]"+ },+ "configurationSettings": {+ "bytebase.version": "[parameters('bytebaseVersion')]",+ "bytebase.option.port": "[parameters('bytebasePort')]",+ "bytebase.option.data": "/var/opt/bytebase",+ "bytebase.option.external-url": "[parameters('bytebaseExternalUrl')]",+ "bytebase.option.externalPg.url": "[variables('pgUrlValue')]",+ "bytebase.persistence.enabled": "[parameters('persistenceEnabled')]",+ "bytebase.persistence.storage": "[parameters('storageSize')]",+ "bytebase.persistence.storageClass": "[parameters('storageClass')]"+ },+ "configurationProtectedSettings": {},+ "scope": {+ "cluster": {+ "releaseNamespace": "[parameters('namespace')]"+ }+ }+ }+ }+ ],+ "outputs": {+ "extensionName": {+ "type": "string",+ "value": "[variables('extensionName')]"+ },+ "clusterName": {+ "type": "string",+ "value": "[variables('clusterName')]"+ },+ "namespace": {+ "type": "string",+ "value": "[parameters('namespace')]"+ }+ }+}diff --git a/scripts/azure-marketplace/manifest.yaml b/scripts/azure-marketplace/manifest.yamlnew file mode 100644index 0000000000..12f9194654--- /dev/null+++ b/scripts/azure-marketplace/manifest.yaml@@ -0,0 +1,31 @@+applicationName: bytebase+version: 3.11.1+description: Safe database schema change and version control for DevOps teams+publisher: Bytebase+helmChart: ../helm-charts/bytebase+clusterArmTemplate: mainTemplate.json+uiDefinition: createUiDefinition.json+registryServer: bytebase.azurecr.io++# This is the registry where your application images are stored+# For Azure Marketplace, images will be copied to Microsoft's registry+registries:+ - name: bytebase.azurecr.io+ url: bytebase.azurecr.io++# Define the container images used by your application+images:+ - image: bytebase.azurecr.io/bytebase/bytebase:3.11.1+ platform: linux/amd64++# Azure Marketplace cluster extension parameters+extensionRegistrationParameters:+ namespace: bytebase+ extensionType: bytebase+ releaseTrain: stable+ releaseNamespace: bytebase+ defaultScope: cluster++# Supported cluster types: managedClusters (AKS) or connectedClusters (Arc-enabled)+clusterTypes:+ - managedClustersdiff --git a/scripts/azure-marketplace/package.sh b/scripts/azure-marketplace/package.shnew file mode 100755index 0000000000..302c74ebca--- /dev/null+++ b/scripts/azure-marketplace/package.sh@@ -0,0 +1,155 @@+#!/bin/bash++# Azure Marketplace Packaging Script for Bytebase+# This script helps automate the packaging process for Azure Marketplace submission++set -e # Exit on error++# Colors for output+RED='\033[0;31m'+GREEN='\033[0;32m'+YELLOW='\033[1;33m'+NC='\033[0m' # No Color++# Configuration+BYTEBASE_VERSION="3.11.1"+PACKAGE_TOOL_IMAGE="mcr.microsoft.com/container-package-app:latest"+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"+AZURE_MARKETPLACE_DIR="${REPO_ROOT}/scripts/azure-marketplace"++echo -e "${GREEN}=== Bytebase Azure Marketplace Packaging Tool ===${NC}\n"++# Function to print step headers+print_step() {+ echo -e "\n${YELLOW}>>> $1${NC}\n"+}++# Function to check if command exists+command_exists() {+ command -v "$1" >/dev/null 2>&1+}++# Check prerequisites+print_step "Step 1: Checking prerequisites"++if ! command_exists docker; then+ echo -e "${RED}Error: Docker is not installed${NC}"+ exit 1+fi+echo -e "${GREEN}✓ Docker is installed${NC}"++if ! command_exists az; then+ echo -e "${YELLOW}Warning: Azure CLI is not installed. You'll need it for ACR operations.${NC}"+ echo "Install from: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli"+else+ echo -e "${GREEN}✓ Azure CLI is installed${NC}"+fi++if ! command_exists helm; then+ echo -e "${YELLOW}Warning: Helm is not installed. Recommended for local testing.${NC}"+else+ echo -e "${GREEN}✓ Helm is installed${NC}"+fi++# Check if required files exist+print_step "Step 2: Verifying Azure Marketplace artifacts"++required_files=(+ "scripts/azure-marketplace/manifest.yaml"+ "scripts/azure-marketplace/createUiDefinition.json"+ "scripts/azure-marketplace/mainTemplate.json"+ "scripts/azure-marketplace/values-azure.yaml"+ "helm-charts/bytebase/Chart.yaml"+ "helm-charts/bytebase/values.yaml"+)++all_files_exist=true+for file in "${required_files[@]}"; do+ if [ -f "${REPO_ROOT}/${file}" ]; then+ echo -e "${GREEN}✓ ${file}${NC}"+ else+ echo -e "${RED}✗ ${file} not found${NC}"+ all_files_exist=false+ fi+done++if [ "$all_files_exist" = false ]; then+ echo -e "\n${RED}Error: Some required files are missing${NC}"+ exit 1+fi++# Pull the packaging tool+print_step "Step 3: Pulling Microsoft's container-package-app tool"+docker pull ${PACKAGE_TOOL_IMAGE}++# Run validation+print_step "Step 4: Running validation (cpa verify)"+echo "This will validate all your Azure Marketplace artifacts..."++cd "${REPO_ROOT}"++if docker run --rm \+ -v /var/run/docker.sock:/var/run/docker.sock \+ -v "${REPO_ROOT}":/data \+ ${PACKAGE_TOOL_IMAGE} \+ cpa verify; then+ echo -e "\n${GREEN}✓ Validation passed!${NC}"+else+ echo -e "\n${RED}✗ Validation failed!${NC}"+ echo "Please review the errors above and fix them before proceeding."+ exit 1+fi++# Ask if user wants to proceed with build+print_step "Step 5: Build CNAB bundle"+echo "Validation passed successfully!"+echo -e "${YELLOW}Do you want to build and upload the CNAB bundle now?${NC}"+echo "Note: This requires:"+echo " 1. Your Docker image to be pushed to Azure Container Registry"+echo " 2. You to be logged in to ACR (az acr login --name <acr-name>)"+echo ""+read -p "Proceed with build? (y/N): " -n 1 -r+echo++if [[ $REPLY =~ ^[Yy]$ ]]; then+ echo -e "\n${YELLOW}Building CNAB bundle...${NC}"++ if docker run --rm \+ -v /var/run/docker.sock:/var/run/docker.sock \+ -v "${REPO_ROOT}":/data \+ ${PACKAGE_TOOL_IMAGE} \+ cpa buildbundle; then+ echo -e "\n${GREEN}✓ CNAB bundle built and uploaded successfully!${NC}"+ echo -e "\nYou can now proceed to Partner Center to create your offer."+ echo "Follow the instructions in azure-marketplace/README.md (Step 7)"+ else+ echo -e "\n${RED}✗ CNAB bundle build failed!${NC}"+ echo "Common issues:"+ echo " 1. Not logged in to ACR: az acr login --name <acr-name>"+ echo " 2. Docker images not pushed to ACR"+ echo " 3. Image references in manifest.yaml don't match ACR"+ exit 1+ fi+else+ echo -e "\n${YELLOW}Skipping CNAB build.${NC}"+ echo "When you're ready, run:"+ echo " docker run --rm -v /var/run/docker.sock:/var/run/docker.sock -v \$(pwd):/data ${PACKAGE_TOOL_IMAGE} cpa buildbundle"+fi++# Summary+print_step "Next Steps"+echo "1. If you haven't already:"+echo " - Set up Azure Container Registry"+echo " - Build and push your Docker image to ACR"+echo " - Update scripts/azure-marketplace/manifest.yaml with your ACR details"+echo ""+echo "2. Test your createUiDefinition.json:"+echo " https://portal.azure.com/#blade/Microsoft_Azure_CreateUIDef/SandboxBlade"+echo ""+echo "3. Create your offer in Partner Center:"+echo " https://partner.microsoft.com/dashboard"+echo ""+echo "4. For detailed instructions, see:"+echo " scripts/azure-marketplace/README.md"+echo ""+echo -e "${GREEN}Good luck with your Azure Marketplace submission! 🚀${NC}"diff --git a/scripts/azure-marketplace/porter.yaml b/scripts/azure-marketplace/porter.yamlnew file mode 100644index 0000000000..0b54ece309--- /dev/null+++ b/scripts/azure-marketplace/porter.yaml@@ -0,0 +1,43 @@+schemaVersion: 1.0.0+name: bytebase+description: ""+version: 3.11.1+registry: bytebase.azurecr.io+images:+ bytebase:+ name: bytebase/bytebase+ description: ""+ imagetype: docker+ repository: docker.io/bytebase/bytebase+ tag: latest+ digest: ""+mixins:+- exec+- helm3+install:+- helm3:+ name: bytebase+ description: ""+ chart: ../helm-charts/bytebase+ set: {}+uninstall:+- exec:+ description: Not implemented+ command: echo 'Not implemented'+parameters: []+custom:+ deploymentrestrictions:+ mincores: 0+ minnodes: 0+ minkubernetesversion: ""+ requiregpunodes: false+ openshiftallowed: false+ nodetype: ""+ newclusterrequired: false+ clusterarmtemplate: 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 uidefinition: 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 helmchart: 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 extensionregistrationparameters: eyJkZWZhdWx0U2NvcGUiOiJjbHVzdGVyIiwiZXh0ZW5zaW9uVHlwZSI6ImJ5dGViYXNlIiwibmFtZXNwYWNlIjoiYnl0ZWJhc2UiLCJyZWxlYXNlTmFtZXNwYWNlIjoiYnl0ZWJhc2UiLCJyZWxlYXNlVHJhaW4iOiJzdGFibGUiLCJzdXBwb3J0ZWRDbHVzdGVyVHlwZXMiOnt9fQ+ packagingtoolversion: 1.3.41+ testparameterfile: ""+ skipdeployment: falsediff --git a/scripts/azure-marketplace/push-to-acr.sh b/scripts/azure-marketplace/push-to-acr.shnew file mode 100755index 0000000000..363873bf00--- /dev/null+++ b/scripts/azure-marketplace/push-to-acr.sh@@ -0,0 +1,99 @@+#!/bin/bash++# Script to tag and push Bytebase image to Azure Container Registry+# Run this AFTER the Docker build completes++set -e++# Colors+GREEN='\033[0;32m'+YELLOW='\033[1;33m'+RED='\033[0;31m'+NC='\033[0m'++# Configuration+ACR_NAME="bytebase"+ACR_LOGIN_SERVER="bytebase.azurecr.io"+BYTEBASE_VERSION="3.11.1"+LOCAL_IMAGE="bytebase/bytebase:${BYTEBASE_VERSION}"+ACR_IMAGE="${ACR_LOGIN_SERVER}/bytebase/bytebase:${BYTEBASE_VERSION}"++echo -e "${GREEN}=== Bytebase ACR Push Script ===${NC}\n"++# Check if Docker image exists+echo -e "${YELLOW}Step 1: Checking if Docker image exists...${NC}"+if docker image inspect ${LOCAL_IMAGE} > /dev/null 2>&1; then+ echo -e "${GREEN}✓ Image ${LOCAL_IMAGE} found${NC}"+else+ echo -e "${RED}✗ Image ${LOCAL_IMAGE} not found${NC}"+ echo "Please build the image first:"+ echo " docker build -f scripts/Dockerfile -t ${LOCAL_IMAGE} ."+ exit 1+fi++# Check if Azure CLI is installed+echo -e "\n${YELLOW}Step 2: Checking Azure CLI...${NC}"+if command -v az > /dev/null 2>&1; then+ echo -e "${GREEN}✓ Azure CLI is installed${NC}"+else+ echo -e "${RED}✗ Azure CLI is not installed${NC}"+ echo "Install from: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli"+ exit 1+fi++# Login to ACR+echo -e "\n${YELLOW}Step 3: Logging in to Azure Container Registry...${NC}"+echo "ACR: ${ACR_NAME}"+if az acr login --name ${ACR_NAME}; then+ echo -e "${GREEN}✓ Successfully logged in to ACR${NC}"+else+ echo -e "${RED}✗ Failed to login to ACR${NC}"+ echo "Make sure you have access to the ACR: ${ACR_NAME}"+ exit 1+fi++# Tag image for ACR+echo -e "\n${YELLOW}Step 4: Tagging image for ACR...${NC}"+echo "Tagging: ${LOCAL_IMAGE} -> ${ACR_IMAGE}"+if docker tag ${LOCAL_IMAGE} ${ACR_IMAGE}; then+ echo -e "${GREEN}✓ Image tagged successfully${NC}"+else+ echo -e "${RED}✗ Failed to tag image${NC}"+ exit 1+fi++# Push to ACR+echo -e "\n${YELLOW}Step 5: Pushing image to ACR...${NC}"+echo "This may take several minutes depending on your connection speed..."+if docker push ${ACR_IMAGE}; then+ echo -e "\n${GREEN}✓ Image successfully pushed to ACR!${NC}"+else+ echo -e "\n${RED}✗ Failed to push image to ACR${NC}"+ exit 1+fi++# Verify image in ACR+echo -e "\n${YELLOW}Step 6: Verifying image in ACR...${NC}"+if az acr repository show --name ${ACR_NAME} --repository bytebase/bytebase > /dev/null 2>&1; then+ echo -e "${GREEN}✓ Image verified in ACR${NC}"++ # Show image details+ echo -e "\n${GREEN}Image Details:${NC}"+ az acr repository show-tags --name ${ACR_NAME} --repository bytebase/bytebase --output table+else+ echo -e "${YELLOW}⚠ Could not verify image in ACR${NC}"+fi++# Summary+echo -e "\n${GREEN}=== Push Complete! ===${NC}"+echo "Image location: ${ACR_IMAGE}"+echo ""+echo "Next steps:"+echo "1. Run the packaging validation:"+echo " ./scripts/azure-marketplace/package.sh"+echo ""+echo "2. If validation passes, build the CNAB bundle:"+echo " (The package.sh script will prompt you)"+echo ""+echo "3. Create your offer in Partner Center:"+echo " https://partner.microsoft.com/dashboard"diff --git a/scripts/azure-marketplace/values-azure.yaml b/scripts/azure-marketplace/values-azure.yamlnew file mode 100644index 0000000000..30f9569a58--- /dev/null+++ b/scripts/azure-marketplace/values-azure.yaml@@ -0,0 +1,49 @@+# Azure Marketplace specific values+# This file extends the base values.yaml with Azure Marketplace requirements++# Global Azure Marketplace image configuration+# Azure will retag and host images in their registry+global:+ azure:+ images:+ bytebase:+ tag: 3.11.1+ image: bytebase/bytebase+ registry: bytebase.azurecr.io++# Standard Bytebase configuration+bytebase:+ version: 3.11.1+ registryMirrorHost: ""+ option:+ port: 8080+ data: "/var/opt/bytebase"+ external-url: "https://bytebase.example.com"+ externalPg:+ url: ""+ existingPgURLSecret: ""+ existingPgURLSecretKey: ""+ pgHost: "host"+ pgPort: "5432"+ pgUsername: "username"+ pgPassword: "password"+ pgDatabase: "database"+ existingPgPasswordSecret: ""+ existingPgPasswordSecretKey: ""+ escapePassword: false+ persistence:+ enabled: true+ existingClaim: ""+ storage: 10Gi+ storageClass: ""+ resources:+ limits:+ cpu: 2000m+ memory: 4Gi+ requests:+ cpu: 1000m+ memory: 1Gi+ extraSecretMounts: []+ extraVolumes: []+ affinity: {}+ tolerations: []