Yes, but how are you decoupling each consumer here? Multiple consumers are still going to receive th

P

Paul•5/16/24, 12:02 AM

The only other way I can think to do it is have the main consumer as a “dispatch” and have it send the event back out on a bunch of other queues, but this sounds terrible

MMatt Silverlock Yes, but how are you decoupling each consumer here? Multiple consumers are still...

P

Paul•5/16/24, 12:03 AM

I’m looking for essentially pub/sub but with at least once guarantee

PPaul I’m looking for essentially pub/sub but with at least once guarantee

M

Matt SilverlockOP•5/16/24, 12:05 AM

Can you describe more here? A Pub/Sub consumer is going to pull something off the topic, but it’s all the same set of messages. I don’t see how this is any more decoupled: a single “UserSignedUp” event is still going to a single consumer.

M

Matt SilverlockOP•5/16/24, 12:05 AM

Publisher writes UserSignedUp event to /sign-ups topic -> consumer pulls off the topic (messages do not persist!) -> now consumer has to fire off all of those events (write to DB, send email, etc)

MMatt Silverlock Publisher writes UserSignedUp event to /sign-ups topic -> consumer pulls off the...

P

Paul•5/16/24, 12:08 AM

I would like a consumer dedicated to writing to DB, and a separate consumer dedicated to notification, etc.

I believe these are called “consumer groups”, like in Kafka.

Now in the future, if I want to perform some other completely decoupled operation, I can simply add another consumer group to the queue (and I don’t have to modify any of the existing consumer processes)

U

Unsmart•5/16/24, 12:08 AM

I think the easiest product to compare to is SNS.

Basically SNS -> (many different) SQS -> Lambda but on cloudflare.

P

Paul•5/16/24, 12:10 AM

Then there’s the whole replay feature, in case new consumer groups need to replay the events from some set point — but then you are just reimplementing Kafka , but damn that would be insanely powerful

PPaul I would like a consumer dedicated to writing to DB, and a separate consumer dedi...

M

Matt SilverlockOP•5/16/24, 12:12 AM

Got it, which means you need some way of fanning out and consuming the same event/message N-many times for (actively!) connected subscribers.

Something we’ve discussed but no timeline on that yet.

MMatt Silverlock Got it, which means you need some way of fanning out and consuming the same even...

P

Paul•5/16/24, 12:12 AM

Yes, and have that “at least once” guarantee for each of the subscribers

P

Paul•5/16/24, 12:13 AM

…since there could be multiple critical parallel operations I’m running on that event

J

johtso•5/16/24, 1:36 PM

what's the best practice for type safe queues? define a zod schema and check the payload, and reject it if it doesn't match the expected shape?

J

johtso•5/16/24, 1:37 PM

also is there not a way to expicitly reject a message and have it go directly to the DLQ?

Jjohtso what's the best practice for type safe queues? define a zod schema and check the...

H

Hello, I’m Allie!•5/16/24, 1:41 PM

Assuming you control all of the producers, I would probably not bother validating it on the consumer, since consumers should only ever push valid messages

Jjohtso also is there not a way to expicitly reject a message and have it go directly to...

H

Hello, I’m Allie!•5/16/24, 1:42 PM

Ack the message then push to the DLQ manually? It isn't quite the same, but it performs the same task

HHello, I’m Allie!Ack the message then push to the DLQ manually? It isn't quite the same, but it p...

J

johtso•5/16/24, 2:23 PM

yeah, thought that was probably the way to go

HHello, I’m Allie!Assuming you control all of the producers, I would probably not bother validatin...

J

johtso•5/16/24, 2:23 PM

sure, the message might have been valid once upon a time, but code changes

J

johtso•5/16/24, 2:24 PM

a key being renamed, and the consumer still expecting it to be there could mean an

undefined

undefined

undefined

undefined causing all sorts of problems

Jjohtso sure, the message might have been valid once upon a time, but code changes 🙂

H

Hello, I’m Allie!•5/16/24, 2:26 PM

Maybe version it? Add a key at the top level with a version ID, then check just that

J

johtso•5/16/24, 2:31 PM

when you have Zod, everything looks like a nail

Jjohtso when you have Zod, everything looks like a nail 😂

H

Hello, I’m Allie!•5/16/24, 2:33 PM

Yeah, Zod is definitely the one-hit hammer here. Just think it is a little heavy-handed to validate the entire thing when you control both sides anyway

H

Hello, I’m Allie!•5/16/24, 2:33 PM

But IDK, both work

M

Michael Wittig•5/16/24, 3:23 PM

I started to experiment with R2 Event Notifications over Queues using http pull. My feedback:
1) Default Api limit of 1200 reqs/5min is 4 req/sec seems way to low. I have 100+ EC2 instances working on a queue. I just requested a limit increase to 30000 reqs/5min. I hope it will be approved. I never hit an SQS rate limit...
2) One of the most important missing features is to extend the visibility timeout while working on a message. At the moment I can only set the visibility timeout when I poll a message. At this time, I might not know how long I need to process it.
3) Jurisdiction support is missing.
4) The R2 event should contain a property jurisdiction.
I hope that helps.

Aaviplayer Hi, what consumer about concurrency? How it works? If I send message into the qu...

J

johtso•5/16/24, 10:41 PM

Is your consumer a cloudflare worker using a binding like this?

[[queues.consumers]]
queue = "my-queue"

[[queues.consumers]]
queue = "my-queue"

[[queues.consumers]]
queue = "my-queue"

[[queues.consumers]]
queue = "my-queue"

J

johtso•5/16/24, 10:41 PM

if so what are your settings?

J

johtso•5/16/24, 10:42 PM

you probably want to change your batch size to 1

J

johtso•5/16/24, 10:42 PM

max_batch_size = 1

J

johtso•5/16/24, 10:42 PM

otherwise both jobs will be given to a single consumer in a batch

J

johtso•5/16/24, 10:43 PM

that should process the jobs in parallel..

J

johtso•5/16/24, 10:47 PM

@aviplayer hmm.. reading this, cloudflare scales the number of consumers based on how many messages are being added to the queue, attempting to avoid the queue growing faster than it is processed. I wonder if it just behaves strangely if you have a very small number of jobs that take a long time to execute https://developers.cloudflare.com/queues/configuration/consumer-concurrency/

J

johtso•5/16/24, 10:47 PM

it might only end up spinning up a single consumer

J

johtso•5/16/24, 10:49 PM

@aviplayer I'm guessing your job is CPU bound rather than IO bound?

Aaviplayer Yes, I tried only with 2 messages, just send one than send second @johtso it jus...

J

johtso•5/17/24, 9:13 AM

Aha, in that case, maybe better to do batches and process them in parallel in your worker using Promise.all and ack each message as and when it is processed

J

johtso•5/17/24, 9:15 PM

I'd be interested to know too what the expected concurrency behaviour is with low throughput..

J

johtso•5/17/24, 10:16 PM

Maybe you'd want something like a minimum concurrency setting

J

johtso•5/17/24, 10:27 PM

@aviplayer another idea.. again not ideal. Have a long running durable object that uses the http pull method to get messages from the queue

P

Praefe•5/19/24, 11:21 PM

Hi team,
We're currently trying to use queues for api request fallbacks, so we've setup a queue workers project.
This worker, on fetch and queue consume, sends an API request to our server (which is covered by cloudflare), and if fails, then re-queues it (until configured retries)

Our problem is, we've got Cloudflare Zero Trust Access on our test server, and it's redirecting our queued requests in test environment to the Zero Trust Access login page. We've tried setting CF-Access-Client-Id and CF-Access-Client-Secret on the HTTP request to our server, but it appears to be getting stripped out at some point down the line (we believe that it's cloudflare doing this).

Any guidance on getting workers working together with Zero Trust Access?

P

Praefe•5/19/24, 11:23 PM

Maybe this is more of a workers question, I don't know if we try and do this anywhere else, will try and get more info on that

F

Fokke•5/20/24, 5:32 PM

I am trying to deploy the basic queue template worker (which worked last week) and am getting this error.

✘ [ERROR] A request to the Cloudflare API (/accounts/[REDACTED]/queues/[REDACTED]/consumers) failed.
workers.api.error.unknown [code: 10013]

Any idea what is going wrong here?

J

johtso•5/20/24, 6:06 PM

how do I safely move a message into a "failure" queue? wont there be a chance that adding the message to the other queue succeed, but removing it from the first fails, or vice versa?

M

Maltmax•5/20/24, 7:51 PM

Hey! When looking at the docs it says that the consumer invocation duration is 15 minutes. But I seem to always run into a CPU Limit reached error. I am using the browser rendering API to screenshot a website, which works fine if I call it through my Hono endpoint. But if I, from my Hono endpoint, send the url to a queue it times out. My code is below and I would greatly appreciate any pointers as to might be wrong as I've been stuck on this for a while haha. Thanks in advance!

M

Maltmax•5/20/24, 7:51 PM

Calling this endpoint from my browser takes between 30-60 seconds and works just fine:

app.get('/manual-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    const fullPageScreenshotUrl = await takeScreenshot(c.env.MYBROWSER, c.env.SCREENSHOT_BUCKET, url); // Function that takes screenshot, uploads to R2 bucket, and returns URL
       return c.json({ fullPageScreenshotUrl });
});

app.get('/manual-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    const fullPageScreenshotUrl = await takeScreenshot(c.env.MYBROWSER, c.env.SCREENSHOT_BUCKET, url); // Function that takes screenshot, uploads to R2 bucket, and returns URL
       return c.json({ fullPageScreenshotUrl });
});

app.get('/manual-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    const fullPageScreenshotUrl = await takeScreenshot(c.env.MYBROWSER, c.env.SCREENSHOT_BUCKET, url); // Function that takes screenshot, uploads to R2 bucket, and returns URL
       return c.json({ fullPageScreenshotUrl });
});

app.get('/manual-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    const fullPageScreenshotUrl = await takeScreenshot(c.env.MYBROWSER, c.env.SCREENSHOT_BUCKET, url); // Function that takes screenshot, uploads to R2 bucket, and returns URL
       return c.json({ fullPageScreenshotUrl });
});

Calling this endpoint, always leads to the queue function timing out:

app.get('/take-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    // Add to queue
    await c.env.ScreenshotQueue.send({ url });

    return c.json({ message: 'success' });
});

export default {
    fetch: app.fetch,
    async queue(batch, env): Promise<void> {
        console.log(batch);
        const messages = JSON.stringify(batch.messages);
        console.log(`consumed from our queue: ${messages}`);
        switch (batch.queue) {
            case 'screenshot-queue':
                for (const message of batch.messages) {
                    const { url } = message.body;
                    if (!url) {
                        console.error('Missing URL');
                        return;
                    }

                    const fullPageScreenshotUrl = await takeScreenshot(env.MYBROWSER, env.SCREENSHOT_BUCKET, url);
                    console.log(fullPageScreenshotUrl)
                     message.ack();
                }
                break;
        }
    },
} satisfies ExportedHandler<Env>;

app.get('/take-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    // Add to queue
    await c.env.ScreenshotQueue.send({ url });

    return c.json({ message: 'success' });
});

export default {
    fetch: app.fetch,
    async queue(batch, env): Promise<void> {
        console.log(batch);
        const messages = JSON.stringify(batch.messages);
        console.log(`consumed from our queue: ${messages}`);
        switch (batch.queue) {
            case 'screenshot-queue':
                for (const message of batch.messages) {
                    const { url } = message.body;
                    if (!url) {
                        console.error('Missing URL');
                        return;
                    }

                    const fullPageScreenshotUrl = await takeScreenshot(env.MYBROWSER, env.SCREENSHOT_BUCKET, url);
                    console.log(fullPageScreenshotUrl)
                     message.ack();
                }
                break;
        }
    },
} satisfies ExportedHandler<Env>;

app.get('/take-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    // Add to queue
    await c.env.ScreenshotQueue.send({ url });

    return c.json({ message: 'success' });
});

export default {
    fetch: app.fetch,
    async queue(batch, env): Promise<void> {
        console.log(batch);
        const messages = JSON.stringify(batch.messages);
        console.log(`consumed from our queue: ${messages}`);
        switch (batch.queue) {
            case 'screenshot-queue':
                for (const message of batch.messages) {
                    const { url } = message.body;
                    if (!url) {
                        console.error('Missing URL');
                        return;
                    }

                    const fullPageScreenshotUrl = await takeScreenshot(env.MYBROWSER, env.SCREENSHOT_BUCKET, url);
                    console.log(fullPageScreenshotUrl)
                     message.ack();
                }
                break;
        }
    },
} satisfies ExportedHandler<Env>;

app.get('/take-screenshot', async (c) => {
    const url = c.req.query('url');
    if (!url) {
        return c.json({ message: 'Please provide a URL' });
    }
    // Add to queue
    await c.env.ScreenshotQueue.send({ url });

    return c.json({ message: 'success' });
});

export default {
    fetch: app.fetch,
    async queue(batch, env): Promise<void> {
        console.log(batch);
        const messages = JSON.stringify(batch.messages);
        console.log(`consumed from our queue: ${messages}`);
        switch (batch.queue) {
            case 'screenshot-queue':
                for (const message of batch.messages) {
                    const { url } = message.body;
                    if (!url) {
                        console.error('Missing URL');
                        return;
                    }

                    const fullPageScreenshotUrl = await takeScreenshot(env.MYBROWSER, env.SCREENSHOT_BUCKET, url);
                    console.log(fullPageScreenshotUrl)
                     message.ack();
                }
                break;
        }
    },
} satisfies ExportedHandler<Env>;

Original message was deleted

P

Praefe•5/20/24, 11:57 PM

The docs literally tell you to set cf headers???????

Yes, but how are you decoupling each consumer here? Multiple consumers are still going to receive th

Similar Threads