Lambda部署包过大，仅保留库中所需代码是否可行及实现方法？

Absolutely! These are two of the most widely adopted strategies for tackling Lambda's deployment size limits—countless developers have used them successfully, especially when working with resource-heavy tasks like image processing. Let’s break down your questions with real-world context:

Have other developers tried these optimization approaches? #

• Consolidating libraries: This is a go-to move for many teams. For image processing specifically, developers often swap multiple niche libraries (like separate packages for resizing, cropping, and format conversion) for a single, all-in-one tool such as sharp (Node.js) or Pillow (Python). These libraries are built to be efficient, and using one eliminates redundant dependencies that bloat your package. I’ve seen teams cut their deployment size by 50%+ just by making this switch.
• Trimming unused code from libraries: This is more hands-on but incredibly effective. Developers regularly use tools to strip out unused modules, documentation, test files, and even unused function definitions from their dependencies. For example, in Node.js, bundlers like esbuild or webpack with tree-shaking can automatically eliminate unused code. In Python, folks use tools like PyInstaller with custom specs, or manually prune folders like tests, docs, and example files from installed packages. Some even compile libraries from source to include only the features they need (e.g., disabling unused image formats in sharp).

How to identify exactly which files/code your code actually depends on? #

The approach varies a bit by language, but here are proven methods:

For Node.js #

• Bundle analyzers: Use webpack-bundle-analyzer or esbuild’s built-in analysis to visualize your bundled code. These tools show you exactly which modules and files are included in the final bundle, so you can spot unused dependencies or large, unnecessary chunks.
• Dependency tree inspection: Run npm ls to get a full tree of your dependencies, then cross-reference it with your code imports to spot libraries you don’t actually use.
• Runtime tracing: Use the --trace-modules flag when running your code locally to see which modules are loaded at runtime. This helps you confirm which parts of a library are actually being utilized.

For Python #

• Coverage tracking: Use coverage.py to run your test suite (or simulate Lambda invocations locally). It will show you exactly which lines of code in your dependencies are executed. You can then safely remove any files/modules that aren’t marked as covered.
• Dependency tree tools: pipdeptree generates a clear tree of your dependencies, making it easy to spot transitive dependencies you don’t need. You can also use pip check to identify unused packages.
• File system tracing: Tools like py-spy or the built-in trace module can track which files are accessed during runtime. This is especially useful for identifying hidden dependencies that don’t show up in static import statements.

General Tips #

• Test locally with Lambda emulators: Use tools like sam local invoke or serverless invoke local to simulate Lambda’s environment. This helps you catch cases where a dependency might load files dynamically that you wouldn’t catch with static analysis.
• Prune manually (carefully): After identifying unused files, you can manually delete folders like tests, __pycache__, .git, and documentation from your dependency directories. Just make sure to test thoroughly afterward to avoid breaking your code.

内容的提问来源于stack exchange，提问作者Aditya Rustagi