> ## Documentation Index
> Fetch the complete documentation index at: https://docs.akua.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Application Sources
> Choose the GitHub, chart, or image sources Akua packages for installation
Application sources define where your application comes from and how Akua turns it into a Package version. You can use authored `package.k`, Helm chart sources from Artifact Hub, GitHub repositories that produce container builds, or pre-built Docker images. See [Packages](/packages#package-first-deployment-second) for the Package contract model.
## Source types
Build images for Package versions
Package stacks from Artifact Hub
Package pre-built container images
## GitHub repositories
Use GitHub repositories as build inputs for Package versions. Akua can build container images with Railpack, then you configure the Package version that installs that image.
When you connect a GitHub repository, Railpack analyzes your code and detects your language and framework. It builds containerized applications without requiring a Dockerfile, with defaults for Node.js, Python, Go, Ruby, and more. The build gives you an image to use in a Package version; production settings still belong in the Package.
GitHub repositories work well for custom applications and APIs, rapid development and iteration, and modern web frameworks like Next.js, SvelteKit, FastAPI, and Django. They're also ideal for monorepos, microservices, and team projects where you want to integrate with your existing development workflow.
### Connecting GitHub
Akua uses a GitHub App for secure, scoped access to your repositories. This provides enhanced security without storing personal access tokens, granular permissions to control which repositories are accessible, and team access so all workspace members can use connected repositories. You can connect both personal and organization accounts.
Get started by connecting your GitHub account or organization
### Language support
Railpack supports common web application languages and frameworks. See [GitHub build workflows](/tools/github-actions#supported-languages) for the current support list.
### Deploying open source projects
Package open source projects that do not have chart sources or Docker images by forking them and building through GitHub repositories. This gives you a container image starting point for applications that have not been containerized or packaged yet.
Fork the project on GitHub, connect your fork to Akua, and Railpack detects the language and framework before building the container image. You still review the generated Package settings, customer inputs, and networking before you use that version in an Offer or direct installation.
This approach works well for projects that are still in development, applications that have not been packaged for Kubernetes, or when you want to test a specific version or fork with custom modifications. You get containerization help without skipping the Package version review.
GitHub repositories use Akua's reusable build path to build images automatically. Akua then creates a Package version from the built image, generated inputs, and routing settings. See [Package generation](/installs/chart-generation) for the installation model.
Use the [launch readiness checklist](/installs#launch-readiness) before sending customers to an Offer created from a source-built Package.
## Chart sources
Package applications from the Helm ecosystem via [Artifact Hub](https://artifacthub.io). Chart sources provide production-ready Kubernetes configurations maintained by the community, with thousands of applications available for databases, web servers, monitoring tools, and more.
You can search Artifact Hub directly in the product creation flow, selecting from popular applications or searching for specific packages. Akua vendors chart sources into a Package version and provisions a per-installation repository for every customer. Configure pricing and make it available to customers.
Chart sources work well for standard software stacks like PostgreSQL, Redis, NGINX, WordPress, and Grafana. They are also useful for enterprise applications with complex Kubernetes configuration and teams that already know Helm. You can customize applications using inputs, and many charts come from verified publishers for added reliability.
Multiple chart sources are composed into a single Package version with all dependencies vendored into each installation's repository.
Look for charts with verified publisher badges for added reliability and security.
### Version selection
When creating application sources from Artifact Hub, you can select specific chart versions to control which version is used in your Package. This lets you:
* Pin to specific chart versions for stability
* Track different chart versions across multiple products
* Manage version updates independently for each application source
Support for selecting chart versions in Artifact Hub when creating application sources is planned for a future release. This will provide more granular control over source version selection and tracking.
## Docker images
Package pre-built container images from any public registry. Docker images give you full control over the build process, work with any programming language or stack, and let you use images you've already built.
You can search for images from Docker Hub or AWS ECR Public Gallery, or manually enter an image URL from any public registry. Akua pulls the image from the registry and generates a versioned Package that can be installed on your selected clusters. Configure pricing and availability to make it available to customers.
Docker images work well for legacy applications with complex build requirements, multi-stage builds with specific optimizations, images requiring special dependencies or configurations, and teams with established Docker workflows.
### Searchable registries
Akua provides search functionality for two major container registries:
**Docker Hub** - Search millions of official and community-maintained container images. Docker Hub includes official images from software vendors and community contributions covering databases, web servers, development tools, and more.
**AWS ECR Public Gallery** - Search the AWS ECR Public Gallery, which aggregates container images from multiple registry aliases including Amazon, Docker, Bitnami, and AWS. ECR Public Gallery provides verified, production-ready images with detailed metadata and security scanning.
### Manual image input
You can also manually enter any Docker image URL from any public registry. This works with:
* Docker Hub (`docker.io/library/nginx:latest`)
* GitHub Container Registry (`ghcr.io/owner/image:tag`)
* AWS ECR (`public.ecr.aws/registry/repo:tag`)
* Quay.io (`quay.io/owner/image:tag`)
* Any other public OCI-compatible registry
### Image format
Specify images using standard Docker notation:
```text theme={null}
nginx:latest
redis:7-alpine
ghcr.io/owner/image:v1.2.3
docker.io/library/postgres:15
public.ecr.aws/bitnami/wordpress:latest
```
For private images, configure your registry credentials in **Settings → Registries**. Akua's registry proxy handles authentication automatically. [Learn more →](/platform/private-registries)
## Package generation
When you create a product with multiple sources, Akua composes them into a Package version. Each version has a semantic version (for example, `0.1.0`, `0.1.1`). When a customer installs the product, Akua provisions a [private installation repository](/installs/repositories) with the vendored sources, the customer's inputs, and the rendered Kubernetes manifests.
How Akua packages installations.
## Choosing the right source
Select the best Package source for your use case:
| Use Case | Recommended Source | Why |
| ---------------------------------------------- | ----------------------------------- | ---------------------------------------------------------- |
| Standard database (PostgreSQL, MySQL, MongoDB) | **Chart source** | Battle-tested Kubernetes configuration |
| Custom web API | **GitHub repo** | Fast iteration, automatic builds |
| Existing containerized app | **Docker image** | Full control, existing workflows |
| Open source applications | **Chart source** | Community maintained, well documented |
| Rapid prototyping | **GitHub repo** | Quick image builds before you finalize the Package version |
| Microservices | **GitHub repo** or **Docker image** | Flexible, supports both approaches |
## Security considerations
Verify publisher badges before deployment. Review chart source code when possible. Keep chart versions updated for security patches. Use Akua's built-in scanning for vulnerabilities.
Ensure repository is private if it contains secrets. Use environment variables for sensitive configuration. Review Railpack build logs for unexpected behavior. Enable branch protection on source repositories.
Only use images from trusted registries. Verify image signatures when available. Scan images for vulnerabilities before deployment. Use specific version tags instead of `latest`.
## API
Manage Packages and source-derived input schemas programmatically.
Create Packages, inspect versions, and fetch generated input schemas.
Fetch the schema that drives generated install and Offer forms.
## Related topics
How Akua creates a per-install repository from your sources.
The git-backed model behind every installation.
Package your sources into sellable products.
Convert Docker Compose files to Kubernetes resources.