How to Move Apps into ACC?

If you've been developing a web application locally using the Django framework and are now ready to take it live, deploying it to ACC is a powerful next step. ACC provides a scalable, cloud-native environment designed for modern commerce applications, allowing you to host, build, and manage your apps with ease.

1

If your application is written in Python using the Django framework, your local project directory may look like this:

├── manage.py
├── quickstart
│   ├── __init__.py
│   ├── __pycache__
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── requirements.txt

2

After setting up and running the application locally, you should see the expected output in the browser.

3

To run your application on ACC, you’ll need to add three essential files to your project directory:

• akinon.json – This JSON file contains the manifest-level information of your application.

• Procfile – Includes the necessary commands to run the application within ACC.

• build.sh – ACC stores image files for each new version of the application. This shell script file should contain the package contents of these image files and instructions on how they should be executed.

Sample akinon.json:

{
 "name": "Quickstart Project",
 "description": "Quickstart Project",
 "scripts": {
   "release": "",
   "build": "sh build.sh"
 },
 "env": {},
 "formation": {
   "web": {
     "min": 1,
     "max": "auto"
   }
 },
 "runtime": "python:3.8-alpine",
 "addons": []
}

4

By including this file, specific requirements for ACC are defined regarding the Docker image of the application. This configuration guides versioning and the necessary commands during the build and release stages. It is important to note that the akinon.json file offers additional opportunities beyond these essentials. For more detailed information, refer to the ACC App Manifest (akinon.json) and Procfile.

5

Next, the contents of the build. sh file will be explored:

set -euo pipefail

apk add python3-dev g++ jpeg-dev zlib-dev libffi-dev --no-cache
pip install -U --force-reinstall pip
pip install -r requirements.txt

apk del g++ python3-dev

Including this file allows specification of the actions ACC must take with the version image whenever a new version is built.

6

Finally, the Procfile must be added.

web: gunicorn quickstart.wsgi -w 4 -b 0.0.0.0:8008 --access-logfile -

Given that the Gunicorn library is being used to handle the web part of our application, it is crucial to specify the appropriate command in the Procfile using the standard format mentioned earlier.

The provided command is responsible for running our application and setting the format for access logs. If you wish to run your own application, ensure that you input the required command in the 'web: command' format.

The web: prefix is required, and the app must run on port 8008, which is the only supported port in ACC.

7

Three essential files have been added to the application directory. As a result, the application directory should now resemble the following:

├── Procfile
├── akinon.json
├── build.sh
├── manage.py
├── quickstart
│   ├── __init__.py
│   ├── __pycache__
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── requirements.txt

8

Your app is now ready to be deployed to ACC.

Creating a Public Key​

To enable ACC to create a repository for the application and allow for development submissions, users must register an SSH Public Key within the ACC. If a Public Key has been previously provided, this step can be skipped.

1

To create an SSH Public Key, users can use the following command:

ssh-keygen -t rsa -b 4096

2

This command has created a Private and a Public Key. The Public Key will be generated under the .pub extension. Next, copy this Public Key:

pbcopy < ~/.ssh/acc_rsa.pub

3

If pbcopy doesn’t work, open the file manually and copy its contents. Then paste it into ACC.

For more info, see the Public Keys documentation.

Creating an Application​

Applications within the ACC are stored in git repositories. To publish each version, users must push the corresponding tag to the git repository in ACC.

If the application is not currently versioned with git, a git repository can be created within the application directory by running the following command through the terminal:

1

If you're not currently versioning the application with git, create a git repository within the application by running the following command in the application directory through the terminal:

git init

2

To link your git repository in the local environment to the one within ACC, first add a new remote registry to your local git repository.

• remote_name: For clarity, consider using a name that includes "acc" to distinguish it from your development repo.

• remote_address: Copy and paste the URL that starts with "ssh://" of your application from the application list on the “My Applications” page in ACC into this field.

git remote add [remote_name] [remote_address]

3

Lastly, execute the following command:

git remote add acc ssh://[email protected]/v1/repos/abcdefghe-abcdefhgh

4

To verify whether you have successfully added it, run this command:

git remote -v

5

The application can now be sent from the local environment to ACC. Create a new tag and push the first version.

git add .
git commit -m "Quickstart v1.0.0"
git tag v1.0.0
git push acc v1.0.0

6

After running the commands above, the v1.0.0 tag will be sent to the ACC repository.

The next step is to initiate the version build corresponding to this tag.

Building Versions​

1

Go to the “My Applications” page in the ACC dashboard. Click on the name of your application. You’ll be directed to the application’s detail page, which includes a section for builds.

2

Follow the instructions under the “Building Application” section of the My Application documentation to trigger the build process.

3

As your version is being built, you'll see one of the following statuses:

• Initializing: The build has started and is being prepared.

• Completed: The build finished successfully and is ready to deploy.

• Failed: The build encountered an error.

If the status shows Failed, click on the build to view the error logs and troubleshoot the issue.

Once the build is marked Completed, you're ready to move on to deployment.

Creating a Project​

In ACC, applications are installed into projects, which allow you to run different versions of your app in different environments (e.g., staging, production).

• If you already have a project, you can skip this step.

• If not, follow the steps outlined in the “Creating Project” section of the Project and Services documentation.

Installing the Application​

As there is currently no project linked to Omnitron, the next step is to install the application into a project. To do this, follow the steps outlined in the App Store documentation under “Adding an Application to a Project.”

Deploying the Application to the Project​

1

Go back to “My Applications” and click on your application’s name. Scroll to the Installed Projects section to see which project the app is installed in.

2

Follow the steps under the “Deploying Application” section in the My Application documentation. Once deployed successfully, the status will be updated to Deployed.

3

Navigate to the Projects page. Select your project and locate your application under the Applications section. Click on the application name to view its details. The application details page includes the URL where the app is running.

4

Click the URL to launch your app—now fully deployed and running in ACC!

Congratulations! Your application is now live on ACC. 🎉

The next step is to ensure your application has access to the necessary data. To configure database connectivity, continue with the Configure Database Connections guide.