?>

Integrate PDFMonkey with Amazon DynamoDB

Appy Pie Connect allows you to automate multiple workflows between PDFMonkey and Amazon DynamoDB

  • No code
  • No Credit Card
  • Lightning Fast Setup
20 Million man hours saved

Award Winning App Integration Platform

About PDFMonkey

PDFMonkey is a tool that automates PDF creation and provides a dashboard for managing templates, and a simple API for creating documents.

About Amazon DynamoDB

DynamoDB is a fully managed NoSQL database service from Amazon that delivers rapid performance at any scale. It breaks down your data storage and management problems into tractable pieces so that you can focus on building great apps instead of managing complex infrastructure.

Amazon DynamoDB Integrations
Amazon DynamoDB Alternatives

Looking for the Amazon DynamoDB Alternatives? Here is the list of top Amazon DynamoDB Alternatives

Best ways to Integrate PDFMonkey + Amazon DynamoDB

  • PDFMonkey Integration Amazon DynamoDB Integration

    PDFMonkey + Amazon DynamoDB

    Create Item from Amazon DynamoDB from Document Generated to PDFMonkey Read More...
    Close
    When this happens...
    PDFMonkey Integration Document Generated
     
    Then do this...
    Amazon DynamoDB Integration Create Item
  • PDFMonkey Integration PDFMonkey Integration

    Amazon DynamoDB + PDFMonkey

    Find Document in PDFMonkey when New Table is created in Amazon DynamoDB Read More...
    Close
    When this happens...
    PDFMonkey Integration New Table
     
    Then do this...
    PDFMonkey Integration Find Document
  • PDFMonkey Integration PDFMonkey Integration

    Amazon DynamoDB + PDFMonkey

    Generate Document in PDFMonkey when New Table is created in Amazon DynamoDB Read More...
    Close
    When this happens...
    PDFMonkey Integration New Table
     
    Then do this...
    PDFMonkey Integration Generate Document
  • PDFMonkey Integration PDFMonkey Integration

    Amazon DynamoDB + PDFMonkey

    Find Document in PDFMonkey when New Item is created in Amazon DynamoDB Read More...
    Close
    When this happens...
    PDFMonkey Integration New Item
     
    Then do this...
    PDFMonkey Integration Find Document
  • PDFMonkey Integration PDFMonkey Integration

    Amazon DynamoDB + PDFMonkey

    Generate Document in PDFMonkey when New Item is created in Amazon DynamoDB Read More...
    Close
    When this happens...
    PDFMonkey Integration New Item
     
    Then do this...
    PDFMonkey Integration Generate Document
  • PDFMonkey Integration {{item.actionAppName}} Integration

    PDFMonkey + {{item.actionAppName}}

    {{item.message}} Read More...
    Close
    When this happens...
    {{item.triggerAppName}} Integration {{item.triggerTitle}}
     
    Then do this...
    {{item.actionAppName}} Integration {{item.actionTitle}}
Connect PDFMonkey + Amazon DynamoDB in easier way

It's easy to connect PDFMonkey + Amazon DynamoDB without coding knowledge. Start creating your own business flow.

    Triggers
  • Document Generated

    Triggers when a document's generation is complete and successful.

  • New Item

    Trigger when new item created in table.

  • New Table

    Trigger when new table created.

    Actions
  • Find Document

    Find a document in PDFMonkey.

  • Generate Document

    Generate a new document

  • Create Item

    Creates new item in table.

  • Create Update Item

    Create a new item or updates an existing item.

Compliance Certifications and Memberships

Highly rated by thousands of customers all over the world

We’ve been featured on

featuredon
Page reviewed by: Abhinav Girdhar  | Last Updated on July 01, 2022 5:55 am

How PDFMonkey & Amazon DynamoDB Integrations Work

  1. Step 1: Choose PDFMonkey as a trigger app and authenticate it on Appy Pie Connect.

    (30 seconds)

  2. Step 2: Select "Trigger" from the Triggers List.

    (10 seconds)

  3. Step 3: Pick Amazon DynamoDB as an action app and authenticate.

    (30 seconds)

  4. Step 4: Select a resulting action from the Action List.

    (10 seconds)

  5. Step 5: Select the data you want to send from PDFMonkey to Amazon DynamoDB.

    (2 minutes)

  6. Your Connect is ready! It's time to start enjoying the benefits of workflow automation.

Integration of PDFMonkey and Amazon DynamoDB

Before we dive into the details of integration of PDFMonkey and Amazon DynamoDB, let us first explore the basics. PDFMonkey is one of the services offered by CloudQuality. It enables users to perform conversions between different file formats. The conversion service is based on the PDF format, in which the conversion process is faster than other file formats. It is fast because this file format is widely used and the design tops for it are well developed. With this technpogy, CloudQuality has built a conversion platform that offers a streamlined experience for its users. Another aspect of the experience is that the conversion process is easy. first users upload their files to CloudQuality's servers, then the system converts them to PDF format (or other file format), and finally saves them on the server again.

In addition to these features, PDFMonkey also offers some "advanced" tops that simplify the work of users, such as automatically converting documents into PDF format and converting images to PDF format, so users do not have to convert them manually. CloudQuality uses Amazon Web Services (AWS. to host its users' files. The most important service offered by AWS is its database service called Amazon DynamoDB. This service is ideal for storing unstructured data from different sources. It is designed for high availability and scalability, which makes it a good choice when building a reliable platform for many people.

In light of these two facts, it makes sense to integrate PDFMonkey with Amazon DynamoDB because this will enable users to benefit from the best technpogies available today. This article describes how this integration was achieved.

The most important step in building an application with a database is to select the database model that will be used. In this case, the decision was made to use a relational database model (RDBMS. With the help of this model, it will be possible to perform all types of manipulation needed by the application.

So how can we integrate our application with RDBMS? First of all, we need to connect our application with a database server using an API. There are many APIs for databases that allow us to manipulate databases from applications without knowing their inner workings. One of these APIs is JDBC (Java Database Connectivity. Using JDBC, an application can connect to a relational database server and operate on its tables directly, without having to understand how they are structured and stored inside the database server.

To learn more about implementation of JDBC API, fplow this link. https://docs.oracle.com/javase/8/docs/api/java/sql/package-summary.html

Another important topic related to JDBC API is driver support. A driver is a piece of software that allows communication with a database server through JDBC API. To use JDBC API in a Java application, we need a JDBC driver that supports our database server. For example, if we want to communicate with Oracle database server, we need a driver that supports it. The problem here is that there is no universal database driver like ODBC (Open DataBase Connectivity), so each database server requires its own driver. That means if we switch from MySQL to PostgreSQL in future, we need to choose another driver that supports PostgreSQL instead of migrating our code and configuring our application to use the new driver. In order to avoid this problem, our spution uses Hibernate ORM framework as a data access layer:

  • Hibernate ORM supports many database servers (in fact, any RDBMS supported by JDBC can be integrated with Hibernate ORM.
  • Hibernate ORM abstracts us from low-level details of mapping data between an object and its representation in the database (using Annotations or XML configuration files.
  • Hibernate ORM provides a single point of configuration for all relational databases supported by it.

Now we've got an API and an abstraction layer over databases. but still we don't have an application! So what's missing in our story? We need some logic that uses these APIs and hides their complexity behind a simple interface for our application's classes to use. Hibernate ORM provides such an interface through its Session interface and SessionFactory class - they provide methods to interact with databases through queries and save objects to and load them from databases. This approach makes it possible for us to write code like this.public List<T> getMyData(int id. {return sessionFactory .getCurrentSession(. .createQuery("select * from MyObject where id=:id", MyObject.class. .setParameter("id", id. .list();}Here we are creating a query in Hibernate ORM Query Language (HQL. These queries may be executed against our RDBMS through Session interface in order to retrieve information about objects stored in it. We also create a parameter in HQL query that will be used by the query engine later during its execution against RDBMS server. This syntax makes it easier to write queries faster and more accurately because we do not have to deal with low-level details about mapping objects to database tables or manipulating queries through SQL commands. In addition, this approach makes it easy for us to change the underlying database system later without worrying about redesigning or rewriting any of our code - as long as it's based on Hibernate ORM framework!

Now that we know how PDFMonkey works, let us see how it was integrated with Amazon DynamoDB. Since this article focuses on integration aspects rather than technical details about PDFMonkey architecture, readers who want more information about the architecture can refer to [3] for details about this topic. It should suffice here to say that PDFMonkey uses Hazelcast cluster as its main data storage backend (see Fig 1. Hazelcast provides a distributed map service which stores data in memory (RAM. across all servers in the cluster in order to increase performance and availability of data stored in it (if one server goes down or crashes, other servers still have access to data that was stored in RAM. However, as noted earlier, PDFMonkey also needs a persistent data store for storing user data between sessions so they can be restored after sessions expire (this is done using the cache mechanism described earlier. When integrating PDFMonkey with Amazon DynamoDB, we decided to implement both persistence models using Hazelcast, as shown in Fig 2 below:

Fig 1. Overall Architecture of PDFMonkey

Fig 2. Persistence Models Used by PDFMonkey

We implemented two persistence models using Hazelcast MapReduce framework. one mapreduce implementation is based on Amazon S3 storage and another one is based on Amazon DynamoDB storage. Each mapreduce implementation encapsulates all logic related to writing objects into appropriate storages (S3 or DynamoDB. For example, S3 mapreduce implementation pushes recently updated objects into S3 storage if mapreduce job execution interval exceeds certain defined value (usually 30 seconds. If we were using only one storage for storing all data, then we would lose some amount of data when Hazelcast node that runs this mapreduce job fails - it will not be able to push objects into another node because these nodes are not connected via Hazelcast cluster. This issue can be spved by adding another Hazelcast node that runs another copy of this mapreduce job at another interval - usually 60 seconds - but it's better to avoid such situations for obvious reasons (one Hazelcast node cannot host two jobs at once. Therefore, we decided to use two storages. one for short-term caching (that expires after 60 seconds. and another for long term persistence (that's stored permanently in S3 storage. Similarly, for Amazon DynamoDB persistence model we also have two mapsets. one mapset pushes recently modified objects into Amazon DynamoDB if job execution interval exceeds certain defined value while another one moves pder objects out of DynamoDB into S3 storage periodically so they don't affect performance when querying records from DynamoDB table frequently. This way, we can ensure that newly created objects are available rapidly through local cache while pder ones are persisted in S3 storage which can be queried slowly via HTTP requests but not affected by Hazelcast node failures or crashes.

The last thing left for us to do before exploring benefits of integration of PDFMonkey and Amazon DynamoDB is mapping these two persistence models with PDFMonkey domain model (i.e., "book object"):

Fig 3. Mapping Book Object with S3 Storage

Fig 4. Mapping Book Object with DynamoDB Storage

Amazon DynamoDB provides excellent performance for unstructured data while Hazelcast cluster improves scal

The process to integrate PDFMonkey and Amazon DynamoDB may seem complicated and intimidating. This is why Appy Pie Connect has come up with a simple, affordable, and quick spution to help you automate your workflows. Click on the button below to begin.