Advanced Security and Threat Mitigation for Github Pages

GitHub Pages offers a reliable platform for static websites, but security should never be overlooked. While Cloudflare provides basic HTTPS and caching, advanced security transformations can protect your site against threats such as DDoS attacks, malicious bots, and unauthorized access. This guide explores comprehensive security strategies to ensure your GitHub Pages website remains safe, fast, and trustworthy.

Quick Navigation for Advanced Security

• Understanding Security Challenges
• Cloudflare Security Features
• Implementing Firewall Rules
• Bot Management and DDoS Protection
• SSL and Encryption Best Practices
• Monitoring Security and Analytics
• Practical Implementation Examples
• Final Recommendations

Understanding Security Challenges

Even static sites on GitHub Pages can face various security threats. Common challenges include unauthorized access, spam bots, content scraping, and DDoS attacks that can temporarily overwhelm your site. Without proactive measures, these threats can impact performance, SEO, and user trust.

Security challenges are not always visible immediately. Slow loading times, unusual traffic spikes, or blocked content may indicate underlying attacks or misconfigurations. Recognizing potential risks early is critical to applying effective protective measures.

Common Threats for GitHub Pages

• Distributed Denial of Service (DDoS) attacks.
• Malicious bots scraping content or attempting exploits.
• Unsecured HTTP endpoints or mixed content issues.
• Unauthorized access to sensitive or hidden pages.

Cloudflare Security Features

Cloudflare provides multiple layers of security that can be applied to GitHub Pages websites. These include automatic HTTPS, WAF (Web Application Firewall), rate limiting, bot management, and edge-based filtering. Leveraging these tools helps protect against both automated and human threats without affecting legitimate traffic.

Security transformations can be integrated with existing performance optimization. For example, edge functions can dynamically block suspicious requests while still serving cached static content efficiently.

Key Security Transformations

• HTTPS enforcement with flexible or full SSL.
• Custom firewall rules to block IP ranges, countries, or suspicious patterns.
• Bot management to detect and mitigate automated traffic.
• DDoS protection to absorb and filter attack traffic at the edge.

Implementing Firewall Rules

Firewall rules allow precise control over incoming requests. With Cloudflare, you can define conditions based on IP, country, request method, or headers. For GitHub Pages, firewall rules can prevent malicious traffic from reaching your origin while allowing legitimate users uninterrupted access.

Firewall rules can also integrate with edge functions to take dynamic actions, such as redirecting, challenging, or blocking traffic that matches predefined threat patterns.

Firewall Best Practices

• Block known malicious IP addresses and ranges.
• Challenge requests from high-risk regions if your audience is localized.
• Log all blocked or challenged requests for auditing purposes.
• Test rules carefully to avoid accidentally blocking legitimate visitors.

Bot Management and DDoS Protection

Automated traffic, such as scrapers and bots, can negatively impact performance and security. Cloudflare's bot management helps identify non-human traffic and apply appropriate actions, such as rate limiting, challenges, or blocks.

DDoS attacks, even on static sites, can exhaust bandwidth or overwhelm origin servers. Cloudflare absorbs attack traffic at the edge, ensuring that legitimate users continue to access content smoothly. Combining bot management with DDoS protection provides comprehensive threat mitigation for GitHub Pages.

Strategies for Bot and DDoS Protection

1. Enable Bot Fight Mode to detect and challenge automated traffic.
2. Set rate limits for specific endpoints or assets to prevent abuse.
3. Monitor traffic spikes and apply temporary firewall challenges during attacks.
4. Combine with caching and edge delivery to reduce load on GitHub origin servers.

SSL and Encryption Best Practices

HTTPS encryption is a baseline requirement for both performance and security. Cloudflare handles SSL certificates automatically, providing flexible or full encryption depending on your GitHub Pages configuration.

Best practices include enforcing HTTPS site-wide, redirecting HTTP traffic, and monitoring SSL expiration and certificate status. Secure headers such as HSTS, Content Security Policy (CSP), and X-Frame-Options further strengthen your site’s defense against attacks.

SSL and Header Recommendations

• Enforce HTTPS using Cloudflare SSL settings.
• Enable HSTS to prevent downgrade attacks.
• Use CSP to control which scripts and resources can be loaded.
• Enable X-Frame-Options to prevent clickjacking attacks.

Monitoring Security and Analytics

Continuous monitoring ensures that security measures are effective. Cloudflare analytics provide insights into threats, blocked traffic, and performance metrics. By reviewing logs regularly, you can identify attack patterns, assess the effectiveness of firewall rules, and adjust configurations proactively.

Integrating monitoring with alerts ensures timely responses to critical threats. For GitHub Pages, this approach ensures your static site remains reliable, even under attack.

Monitoring Best Practices

• Review firewall logs to detect suspicious activity.
• Analyze bot management reports for traffic anomalies.
• Track SSL and HTTPS status to prevent downtime or mixed content issues.
• Set up automated alerts for DDoS events or repeated failed requests.

Practical Implementation Examples

Example setup for a GitHub Pages documentation site:

• Enable full SSL and force HTTPS for all traffic.
• Create firewall rules to block unwanted IP ranges and countries.
• Activate Bot Fight Mode and rate limiting for sensitive endpoints.
• Monitor logs for blocked or challenged traffic and adjust rules monthly.
• Use edge functions to dynamically inject security headers and challenge suspicious requests.

For a portfolio site, applying DDoS protection and bot management prevents spam submissions or scraping of images while maintaining fast access for genuine visitors.

Example Table for Security Configuration

Feature	Configuration	Purpose
SSL	Full SSL, HTTPS enforced	Secure user connections
Firewall Rules	Block high-risk IPs & challenge unknown patterns	Prevent unauthorized access
Bot Management	Enable Bot Fight Mode	Reduce automated traffic
DDoS Protection	Automatic edge mitigation	Ensure site availability under attack
Security Headers	HSTS, CSP, X-Frame-Options	Protect against content and script attacks

Final Recommendations

Advanced security and threat mitigation with Cloudflare complement performance optimization for GitHub Pages. By applying firewall rules, bot management, DDoS protection, SSL, and continuous monitoring, developers can maintain safe, reliable, and fast static websites.

Security is an ongoing process. Regularly review logs, adjust rules, and test configurations to adapt to new threats. Implementing these measures ensures your GitHub Pages site remains secure while delivering high performance and user trust.

Secure your site today by applying advanced Cloudflare security transformations and maintain GitHub Pages with confidence and reliability.

Continuous Optimization for Github Pages with Cloudflare

Optimizing a GitHub Pages website is not a one-time task. Continuous performance improvement ensures your site remains fast, secure, and reliable as traffic patterns and content evolve. Cloudflare provides tools for monitoring, automation, and proactive optimization that work seamlessly with GitHub Pages. This guide explores strategies to maintain high performance consistently while reducing manual intervention.

Quick Navigation for Continuous Optimization

• Importance of Continuous Optimization
• Real-Time Monitoring and Analytics
• Automation with Cloudflare
• Performance Tuning Strategies
• Error Detection and Response
• Practical Implementation Examples
• Final Tips for Long-Term Success

Importance of Continuous Optimization

Static sites like GitHub Pages benefit from Cloudflare transformations, but as content grows and visitor behavior changes, performance can degrade if not actively managed. Continuous optimization ensures your caching rules, edge functions, and asset delivery remain effective. This approach also mitigates potential security risks and maintains high user satisfaction.

Without monitoring and ongoing adjustments, even previously optimized sites can suffer from slow load times, outdated cached content, or security vulnerabilities. Continuous optimization aligns website performance with evolving web standards and user expectations.

Benefits of Continuous Optimization

• Maintain consistently fast loading speeds.
• Automatically adjust to traffic spikes and device variations.
• Detect and fix performance bottlenecks early.
• Enhance SEO and user engagement through reliable site performance.

Real-Time Monitoring and Analytics

Cloudflare provides detailed analytics and logging tools to monitor GitHub Pages websites in real-time. Metrics such as cache hit ratio, response times, security events, and visitor locations help identify issues and areas for improvement. Monitoring allows developers to react proactively, rather than waiting for users to report slow performance or broken pages.

Key monitoring elements include traffic patterns, error rates, edge function execution, and bandwidth usage. Understanding these metrics ensures that optimization strategies remain effective as the website evolves.

Best Practices for Analytics

• Track cache hit ratios for different asset types to ensure efficient caching.
• Monitor edge function performance and errors to detect failures early.
• Analyze visitor behavior to identify slow-loading pages or assets.
• Use security analytics to detect and block suspicious activity.

Automation with Cloudflare

Automation reduces manual intervention and ensures consistent optimization. Cloudflare allows automated rules for caching, redirects, security, and asset optimization. GitHub Pages owners can also integrate CI/CD pipelines to trigger cache purges or deploy configuration changes automatically.

Automating repetitive tasks like cache purges, header updates, or image optimization allows developers to focus on content quality and feature development rather than maintenance.

Automation Examples

1. Set up automated cache purges after each GitHub Pages deployment.
2. Use Cloudflare Transform Rules to automatically convert new images to WebP.
3. Automate security header updates using edge functions.
4. Schedule performance reports to review metrics regularly.

Performance Tuning Strategies

Continuous performance tuning ensures that your GitHub Pages site loads quickly for all users. Strategies include refining caching rules, optimizing images, minifying scripts, and monitoring third-party scripts for impact on page speed.

Testing changes in small increments helps identify which optimizations yield measurable improvements. Tools like Lighthouse, PageSpeed Insights, or GTmetrix can provide actionable insights to guide tuning efforts.

Effective Tuning Techniques

• Regularly review caching rules and adjust TTL values based on content update frequency.
• Compress and minify new assets before deployment.
• Optimize images for responsive delivery using Cloudflare Polish and Mirage.
• Monitor third-party scripts and remove unnecessary ones to reduce blocking time.

Error Detection and Response

Continuous monitoring helps detect errors before they impact users. Cloudflare allows you to log edge function failures, 404 errors, and security threats. By proactively responding to errors, you maintain user trust and avoid SEO penalties from broken pages or slow responses.

Setting up automated alerts ensures that developers are notified in real-time when critical issues occur. This enables rapid resolution and reduces downtime.

Error Management Tips

• Enable logging for edge functions and monitor execution errors.
• Track HTTP status codes to detect broken links or server errors.
• Set up automated alerts for critical security events.
• Regularly test redirects and routing rules to ensure proper configuration.

Practical Implementation Examples

For a GitHub Pages documentation site, continuous optimization might involve:

• Automated cache purges triggered by GitHub Actions after each deployment.
• Edge function monitoring to log redirects and inject updated security headers.
• Real-time image optimization for new uploads using Cloudflare Transform Rules.
• Scheduled reports of performance metrics and security events.

For a personal portfolio site, automation can handle HTML minification, CSS/JS compression, and device-specific optimizations automatically after every content change. Combining these strategies ensures the site remains fast and secure without manual intervention.

Example Table for Continuous Optimization Settings

Task	Configuration	Purpose
Cache Purge	Automated on deploy	Ensure users get latest content
Edge Function Monitoring	Log errors and redirects	Detect runtime issues
Image Optimization	Transform Rules WebP + resize	Reduce load time
Security Alerts	Email/SMS notifications	Respond quickly to threats
Performance Reports	Weekly automated summary	Track improvements over time

Final Tips for Long-Term Success

Continuous optimization with Cloudflare ensures that GitHub Pages sites maintain high performance, security, and reliability over time. By integrating monitoring, automation, and real-time optimization, developers can reduce manual work while keeping their sites fast and resilient.

Regularly review analytics, refine rules, and test new strategies to adapt to changes in traffic, content, and web standards. Continuous attention to performance not only improves user experience but also strengthens SEO and long-term website sustainability.

Start implementing continuous optimization today and make Cloudflare transformations a routine part of your GitHub Pages workflow for maximum efficiency and speed.

Advanced Cloudflare Transformations for Github Pages

<--- layout: post05 title: "" categories: [cloudflare, github, performance] tags: [cloudflare, github pages, edge functions, cache optimization, dns, ssl, image optimization, security, speed, website performance, web development, real-time optimization] description: "Explore advanced Cloudflare transformations to optimize GitHub Pages using edge functions, custom rules, and real-time performance improvements." --->

While basic Cloudflare transformations can improve GitHub Pages performance, advanced techniques unlock even greater speed, reliability, and security. By leveraging edge functions, custom caching rules, and real-time optimization strategies, developers can tailor content delivery to users, reduce latency, and enhance user experience. This article dives deep into these advanced transformations, providing actionable guidance for GitHub Pages owners seeking optimal performance.

Quick Navigation for Advanced Transformations

• Edge Functions for GitHub Pages
• Custom Cache and Transform Rules
• Real-Time Asset Optimization
• Enhancing Security and Access Control
• Monitoring Performance and Errors
• Practical Implementation Examples
• Final Recommendations

Edge Functions for GitHub Pages

Edge functions allow you to run custom scripts at Cloudflare's edge network before content reaches the user. This capability enables real-time manipulation of requests and responses, dynamic redirects, A/B testing, and advanced personalization without modifying the static GitHub Pages source files.

One advantage is reducing server-side dependencies. For example, instead of adding client-side JavaScript to manipulate HTML, an edge function can inject headers, redirect users, or rewrite URLs at the network level, improving both speed and SEO compliance.

Common Use Cases

• URL Rewrites: Automatically redirect old URLs to new pages without impacting user experience.
• Geo-Targeting: Serve region-specific content based on user location.
• Header Injection: Add or modify security headers, cache directives, or meta information dynamically.
• A/B Testing: Serve different page variations at the edge to measure user engagement without slowing down the site.

Custom Cache and Transform Rules

While default caching improves speed, custom cache and transform rules allow more granular control over how Cloudflare handles your content. You can define specific behaviors per URL pattern, file type, or device type.

For GitHub Pages, this is especially useful because the platform serves static files without server-side logic. Using Cloudflare rules, you can instruct the CDN to cache static assets longer, bypass caching for frequently updated HTML pages, or even apply automatic image resizing for mobile devices.

Key Strategies

1. Cache Everything for Assets: Images, CSS, and JS can be cached for months to reduce repeated requests.
2. Bypass Cache for HTML: Keep content fresh while still caching assets efficiently.
3. Transform Rules: Convert images to WebP, minify CSS/JS, and compress text-based assets automatically.
4. Device-Specific Optimizations: Serve smaller images or optimized scripts for mobile visitors.

Real-Time Asset Optimization

Cloudflare enables real-time optimization, meaning assets are transformed dynamically at the edge before delivery. This reduces payload size and improves rendering speed across devices and network conditions. Unlike static optimization, this approach adapts automatically to new assets or updates without additional build steps.

Examples include dynamic image resizing, format conversion, and automatic compression of CSS and JS. Combined with intelligent caching, these optimizations reduce bandwidth, lower latency, and improve overall user experience.

Best Practices

• Enable Brotli Compression to minimize transfer size.
• Use Auto Minify for CSS, JS, and HTML.
• Leverage Polish and Mirage for images to adapt to device screen size.
• Apply Responsive Loading with srcset and sizes attributes for images.

Enhancing Security and Access Control

Advanced Cloudflare transformations not only optimize performance but also strengthen security. By applying firewall rules, rate limiting, and bot management, you can protect GitHub Pages sites from attacks while maintaining speed.

Edge functions can also handle access control dynamically, allowing selective content delivery based on authentication, geolocation, or custom headers. This is particularly useful for private documentation or gated content hosted on GitHub Pages.

Security Recommendations

• Implement Custom Firewall Rules to block unwanted traffic.
• Use Rate Limiting for sensitive endpoints.
• Enable Bot Management to reduce automated abuse.
• Leverage Edge Authentication for private pages or resources.

Monitoring Performance and Errors

Continuous monitoring is crucial for sustaining high performance. Cloudflare provides detailed analytics, including cache hit ratios, response times, and error rates. By tracking these metrics, you can fine-tune transformations to balance speed, security, and reliability.

Edge function logs allow you to detect runtime errors and unexpected redirects, while performance analytics help identify slow-loading assets or inefficient cache rules. Integrating monitoring with GitHub Pages ensures you can respond quickly to user experience issues.

Analytics Best Practices

• Track cache hit ratio for each asset type.
• Monitor response times to identify performance bottlenecks.
• Analyze traffic spikes and unusual patterns for security and optimization opportunities.
• Set up alerts for edge function errors or failed redirects.

Practical Implementation Examples

For a documentation site hosted on GitHub Pages, advanced transformations could be applied as follows:

• Edge Function: Redirect outdated URLs to updated pages dynamically.
• Cache Rules: Cache all images, CSS, and JS for 1 month; HTML cached for 1 hour.
• Image Optimization: Convert PNGs and JPEGs to WebP on the fly using Transform Rules.
• Device Optimization: Serve lower-resolution images for mobile visitors.

For a portfolio site, edge functions can dynamically inject security headers, redirect visitors based on location, and manage A/B testing for new layout experiments. Combined with real-time optimization, this ensures both performance and engagement are maximized.

Example Table for Advanced Rules

Feature	Configuration	Purpose
Cache Static Assets	1 month	Reduce repeated requests and speed up load
Cache HTML	1 hour	Keep content fresh while benefiting from caching
Edge Function	Redirect /old-page to /new-page	Preserve SEO and user experience
Image Optimization	Auto WebP + Polish	Reduce bandwidth and improve load time
Security Headers	Dynamic via Edge Function	Enhance security without modifying source code

Final Recommendations

Advanced Cloudflare transformations provide powerful tools for GitHub Pages optimization. By combining edge functions, custom cache and transform rules, real-time asset optimization, and security enhancements, developers can achieve fast, secure, and scalable static websites.

Regularly monitor analytics, adjust configurations, and experiment with edge functions to maintain top performance. These advanced strategies not only improve user experience but also contribute to higher SEO rankings and long-term website sustainability.

Take action today: Implement advanced Cloudflare transformations on your GitHub Pages site and unlock the full potential of your static website.

Cloudflare Transformations to Optimize GitHub Pages Performance

GitHub Pages is an excellent platform for hosting static websites, but performance optimization is often overlooked. Slow loading speeds, unoptimized assets, and inconsistent caching can hurt user experience and search engine ranking. Fortunately, Cloudflare offers a set of transformations that can significantly improve the performance of your GitHub Pages site. In this guide, we explore practical strategies to leverage Cloudflare effectively and ensure your website runs fast, secure, and efficient.

Quick Navigation for Cloudflare Optimization

• Understanding Cloudflare Transformations
• Setting Up Cloudflare for GitHub Pages
• Caching Strategies to Boost Speed
• Image and Asset Optimization
• Security Enhancements
• Monitoring and Analytics
• Practical Examples of Transformations
• Final Tips for Optimal Performance

Understanding Cloudflare Transformations

Cloudflare transformations are a set of features that manipulate, optimize, and secure your website traffic. These transformations include caching, image optimization, edge computing, SSL management, and routing enhancements. By applying these transformations, GitHub Pages websites can achieve faster load times and better reliability without changing the underlying static site structure.

One of the core advantages is the ability to process content at the edge. This means your files, images, and scripts are delivered from a server geographically closer to the visitor, reducing latency and improving page speed. Additionally, Cloudflare transformations allow developers to implement automatic compression, minification, and optimization without modifying the original codebase.

Key Features of Cloudflare Transformations

• Caching Rules: Define which files are cached and for how long to reduce repeated requests to GitHub servers.
• Image Optimization: Automatically convert images to modern formats like WebP and adjust quality for faster loading.
• Edge Functions: Run small scripts at the edge to manipulate requests and responses.
• SSL and Security: Enable HTTPS, manage certificates, and prevent attacks like DDoS efficiently.
• HTTP/3 and Brotli: Modern protocols that enhance performance and reduce bandwidth.

Setting Up Cloudflare for GitHub Pages

Integrating Cloudflare with GitHub Pages requires careful configuration of DNS and SSL settings. The process begins with adding your GitHub Pages domain to Cloudflare and verifying ownership. Once verified, you can update DNS records to point traffic through Cloudflare while keeping GitHub as the origin server.

Start by creating a free or paid Cloudflare account, then add your domain under the "Add Site" section. Cloudflare will scan existing DNS records; ensure that your CNAME points correctly to username.github.io. After DNS propagation, enable SSL and HTTP/3 to benefit from secure and fast connections. This setup alone can prevent mixed content errors and improve user trust.

Essential DNS Configuration Tips

• Use a CNAME for subdomains pointing to GitHub Pages.
• Enable proxy (orange cloud) in Cloudflare for caching and security.
• Avoid multiple redirects; ensure the canonical URL is consistent.

Caching Strategies to Boost Speed

Effective caching is one of the most impactful ways to optimize GitHub Pages performance. Cloudflare allows fine-grained control over which assets to cache and for how long. By setting proper caching headers, you can reduce the number of requests to GitHub, lower server load, and speed up repeat visits.

One recommended approach is to cache static assets such as images, CSS, and JavaScript for a long duration, while allowing HTML to remain more dynamic. You can use Cloudflare Page Rules or Transform Rules to set caching behavior per URL pattern.

Best Practices for Caching

1. Enable Edge Cache for static assets to serve content closer to visitors.
2. Use Cache Everything with caution; test HTML changes to avoid outdated content.
3. Implement Browser Cache TTL to control client-side caching.
4. Combine files and minify CSS/JS to reduce overall payload.

Image and Asset Optimization

Large images and unoptimized assets are common culprits for slow GitHub Pages websites. Cloudflare provides automatic image optimization and content delivery improvements that dramatically reduce load time. The service can compress images, convert to modern formats like WebP, and adjust sizes based on device screen resolution.

For JavaScript and CSS, Cloudflare’s minification feature removes unnecessary characters, spaces, and comments, improving performance without affecting functionality. Additionally, bundling multiple scripts and stylesheets can reduce the number of requests, further speeding up page load.

Tips for Asset Optimization

• Enable Auto Minify for CSS, JS, and HTML.
• Use Polish and Mirage features for images.
• Serve images with responsive sizes using srcset.
• Consider lazy loading for offscreen images.

Security Enhancements

Optimizing performance also involves securing your site. Cloudflare adds a layer of security to GitHub Pages by mitigating threats, including DDoS attacks and malicious bots. Enabling SSL, firewall rules, and rate limiting ensures that visitors experience safe and reliable access.

Moreover, Cloudflare automatically handles HTTP/2 and HTTP/3 protocols, reducing the overhead of multiple connections and improving secure data transfer. By leveraging these features, your GitHub Pages site becomes not only faster but also resilient to potential security risks.

Key Security Measures

• Enable Flexible or Full SSL depending on GitHub Pages HTTPS setup.
• Use Firewall Rules to block suspicious IPs or bots.
• Apply Rate Limiting to prevent abuse.
• Monitor security events through Cloudflare Analytics.

Monitoring and Analytics

To maintain optimal performance, continuous monitoring is essential. Cloudflare provides analytics that track bandwidth, cache hits, threats, and visitor metrics. These insights help you understand how optimizations affect site speed and user engagement.

Regularly reviewing analytics allows you to fine-tune caching strategies, identify slow-loading assets, and spot unusual traffic patterns. Combined with GitHub Pages logging, this forms a complete picture of website health.

Analytics Best Practices

• Track cache hit ratios to measure efficiency of caching rules.
• Analyze top-performing pages for optimization opportunities.
• Monitor security threats and adjust firewall settings accordingly.
• Use page load metrics to measure real-world performance improvements.

Practical Examples of Transformations

Implementing Cloudflare transformations can be straightforward. For example, a GitHub Pages site hosting documentation might use the following setup:

• Cache static assets: CSS, JS, images cached for 1 month.
• Enable Auto Minify: Reduce CSS and JS size by 30–40%.
• Polish images: Convert PNGs to WebP automatically.
• Edge rules: Serve HTML with minimal cache for updates while caching assets aggressively.

Another example is a portfolio website where user experience is critical. By enabling Brotli compression and HTTP/3, images and scripts load faster across devices, providing smooth navigation and faster interaction without touching the source code.

Example Table for Asset Settings

Asset Type	Cache Duration	Optimization
CSS	1 month	Minify
JS	1 month	Minify
Images	1 month	Polish + WebP
HTML	1 hour	Dynamic content

Final Tips for Optimal Performance

To maximize the benefits of Cloudflare transformations on GitHub Pages, consider these additional tips:

• Regularly audit site performance using tools like Lighthouse or GTmetrix.
• Combine multiple Cloudflare features—caching, image optimization, SSL—to achieve cumulative improvements.
• Monitor analytics and adjust settings based on visitor behavior.
• Document transformations applied for future reference and updates.

By following these strategies, your GitHub Pages site will not only perform faster but also remain secure, reliable, and user-friendly. Implementing Cloudflare transformations is an investment in both performance and long-term sustainability of your static website.

Ready to take your GitHub Pages website to the next level? Start applying Cloudflare transformations today and see measurable improvements in speed, security, and overall performance. Optimize, monitor, and refine continuously to stay ahead in web performance standards.